shokupan 0.10.5 → 0.11.0

package/dist/index.js

@@ -1,24 +1,27 @@
 import { nanoid } from "nanoid";
 import { readFile } from "node:fs/promises";
 import { inspect } from "node:util";
-import { RecordId, Surreal } from "surrealdb";
 import { Eta } from "eta";
 import { stat, readdir, readFile as readFile$1 } from "fs/promises";
 import { resolve, join, sep, basename } from "path";
 import { trace, SpanKind, SpanStatusCode, context } from "@opentelemetry/api";
+import { RecordId, Surreal } from "surrealdb";
 import { dump } from "js-yaml";
+import * as http$1 from "node:http";
+import "node:https";
 import { AsyncLocalStorage } from "node:async_hooks";
-import * as os from "node:os";
-import os__default from "node:os";
 import { dirname, join as join$1 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, URL as URL$1 } from "node:url";
 import renderToString from "preact-render-to-string";
 import { jsxs, jsx, Fragment } from "preact/jsx-runtime";
 import cluster from "node:cluster";
 import net from "node:net";
+import * as os from "node:os";
+import os__default from "node:os";
+import { createRequire } from "node:module";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import { readFileSync } from "node:fs";
-import { OpenAPIAnalyzer } from "./analyzer-BqIe1p0R.js";
+import { OpenAPIAnalyzer } from "./analyzer-CnKnQ5KV.js";
 import * as zlib from "node:zlib";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
@@ -185,12 +188,12 @@ class ShokupanResponse {
 }
 const $isApplication = /* @__PURE__ */ Symbol.for("Shokupan.app");
 const $appRoot = /* @__PURE__ */ Symbol.for("Shokupan.app-root");
-const $isMounted = /* @__PURE__ */ Symbol("Shokupan.isMounted");
-const $routeMethods = /* @__PURE__ */ Symbol("Shokupan.routeMethods");
-const $eventMethods = /* @__PURE__ */ Symbol("Shokupan.eventMethods");
-const $routeArgs = /* @__PURE__ */ Symbol("Shokupan.routeArgs");
-const $controllerPath = /* @__PURE__ */ Symbol("Shokupan.controllerPath");
-const $middleware = /* @__PURE__ */ Symbol("Shokupan.middleware");
+const $isMounted = /* @__PURE__ */ Symbol.for("Shokupan.isMounted");
+const $routeMethods = /* @__PURE__ */ Symbol.for("Shokupan.routeMethods");
+const $eventMethods = /* @__PURE__ */ Symbol.for("Shokupan.eventMethods");
+const $routeArgs = /* @__PURE__ */ Symbol.for("Shokupan.routeArgs");
+const $controllerPath = /* @__PURE__ */ Symbol.for("Shokupan.controllerPath");
+const $middleware = /* @__PURE__ */ Symbol.for("Shokupan.middleware");
 const $isRouter = /* @__PURE__ */ Symbol.for("Shokupan.router");
 const $parent = /* @__PURE__ */ Symbol.for("Shokupan.parent");
 const $childRouters = /* @__PURE__ */ Symbol.for("Shokupan.child-routers");
@@ -227,12 +230,13 @@ function isValidCookieDomain(domain, currentHost) {
   return false;
 }
 class ShokupanContext {
-  constructor(request, server, state, app, signal, enableMiddlewareTracking = false) {
+  constructor(request, server, state, app, signal, enableMiddlewareTracking = false, requestId) {
     this.request = request;
     this.server = server;
     this.app = app;
     this.signal = signal;
     this.state = state || {};
+    this[$requestId] = requestId;
     if (enableMiddlewareTracking) {
       const self = this;
       this.state = new Proxy(this.state, {
@@ -300,7 +304,10 @@ class ShokupanContext {
   get requestId() {
     return this[$requestId] ??= this.app?.applicationConfig?.idGenerator?.() ?? nanoid();
   }
-  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+  [
+    // Only apply a custom inspect symbol in Node.js, Deno, or Bun.
+    globalThis.navigator?.userAgent?.match(/Node\.js|Deno|Bun/) ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : /* @__PURE__ */ Symbol.for("no-op")
+  ]() {
     const innerString = inspect({
       method: this.request.method,
       url: this.request.url,
@@ -435,6 +442,12 @@ class ShokupanContext {
   get res() {
     return this.response;
   }
+  /**
+   * Get the raw response body content (if available)
+   */
+  get responseBody() {
+    return this[$rawBody];
+  }
   /**
    * Raw WebSocket connection
    */
@@ -553,10 +566,10 @@ class ShokupanContext {
    * The body is only parsed once and cached for subsequent reads.
    */
   async body() {
-    if (this[$bodyParseError]) {
+    if (this[$bodyParseError] !== void 0) {
       throw this[$bodyParseError];
     }
-    if (this[$bodyParsed]) {
+    if (this[$bodyParsed] === true) {
       return this[$cachedBody];
     }
     const contentType = this.request.headers.get("content-type") || "";
@@ -674,6 +687,7 @@ class ShokupanContext {
     if (!VALID_HTTP_STATUSES.has(finalStatus)) {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
+    this.response.status = finalStatus;
     const jsonString = JSON.stringify(data instanceof Promise ? await data : data);
     this[$rawBody] = jsonString;
     if (!headers && !this.response.hasPopulatedHeaders) {
@@ -696,6 +710,7 @@ class ShokupanContext {
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(finalStatus)) {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
+    this.response.status = finalStatus;
     this[$rawBody] = data instanceof Promise ? await data : data;
     if (!headers && !this.response.hasPopulatedHeaders) {
       this[$finalResponse] = new Response(this[$rawBody], {
@@ -717,6 +732,7 @@ class ShokupanContext {
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(finalStatus)) {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
+    this.response.status = finalStatus;
     const finalHeaders = this.mergeHeaders(headers);
     finalHeaders.set("content-type", "text/html; charset=utf-8");
     this[$rawBody] = html instanceof Promise ? await html : html;
@@ -730,6 +746,7 @@ class ShokupanContext {
     if (this.app.applicationConfig.validateStatusCodes && !VALID_REDIRECT_STATUSES.has(status)) {
       throw new Error(`Invalid redirect status code: ${status}`);
     }
+    this.response.status = status;
     const finalHeaders = this.mergeHeaders();
     finalHeaders.set("Location", url instanceof Promise ? await url : url);
     this[$finalResponse] = new Response(null, { status, headers: finalHeaders });
@@ -744,6 +761,7 @@ class ShokupanContext {
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(status)) {
       throw new Error(`Invalid HTTP status code: ${status}`);
     }
+    this.response.status = status;
     const finalHeaders = this.mergeHeaders();
     this[$finalResponse] = new Response(null, { status, headers: finalHeaders });
     return this[$finalResponse];
@@ -757,6 +775,7 @@ class ShokupanContext {
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(status)) {
       throw new Error(`Invalid HTTP status code: ${status}`);
     }
+    if (status) this.response.status = status;
     if (typeof Bun !== "undefined") {
       this[$finalResponse] = new Response(Bun.file(path, fileOptions), { status, headers: finalHeaders });
       return this[$finalResponse];
@@ -859,6 +878,91 @@ function deepMerge(target, ...sources) {
   }
   return deepMerge(target, ...sources);
 }
+async function getAstRoutes(applications, options = {}) {
+  const { includePrefix = true, pathTransform } = options;
+  const astRoutes = [];
+  const getExpandedRoutes = (app, prefix = "", seen = /* @__PURE__ */ new Set(), sourceOverride) => {
+    if (seen.has(app.name)) return [];
+    const newSeen = new Set(seen);
+    newSeen.add(app.name);
+    const expanded = [];
+    let currentPrefix = prefix;
+    if (includePrefix && app.controllerPrefix) {
+      const cleanPrefix = currentPrefix.endsWith("/") ? currentPrefix.slice(0, -1) : currentPrefix;
+      const cleanCont = app.controllerPrefix.startsWith("/") ? app.controllerPrefix : "/" + app.controllerPrefix;
+      currentPrefix = cleanPrefix + cleanCont;
+    }
+    for (const route of app.routes) {
+      let path = route.path;
+      if (includePrefix) {
+        const cleanPrefix = currentPrefix.endsWith("/") ? currentPrefix.slice(0, -1) : currentPrefix;
+        const cleanPath = path.startsWith("/") ? path : "/" + path;
+        path = cleanPrefix + cleanPath;
+        if (path.length > 1 && path.endsWith("/")) {
+          path = path.slice(0, -1);
+        }
+      }
+      if (pathTransform) {
+        path = pathTransform(path);
+      } else if (includePrefix && !path.startsWith("/")) {
+        path = "/" + path;
+      }
+      const expandedRoute = {
+        ...route,
+        path: path || "/"
+      };
+      if (sourceOverride) {
+        expandedRoute.sourceContext = sourceOverride;
+      }
+      expanded.push(expandedRoute);
+    }
+    if (app.mounted) {
+      for (const mount of app.mounted) {
+        const targetApp = applications.find((a) => a.name === mount.target || a.className === mount.target);
+        if (targetApp) {
+          let nextPrefix = "";
+          if (includePrefix) {
+            const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+            const mountPrefix = mount.prefix.startsWith("/") ? mount.prefix : "/" + mount.prefix;
+            nextPrefix = cleanPrefix + mountPrefix;
+          }
+          let nextSourceOverride = sourceOverride;
+          if (mount.dependency || mount.targetFilePath && mount.targetFilePath.includes("node_modules")) {
+            if (mount.sourceContext) {
+              nextSourceOverride = {
+                ...mount.sourceContext,
+                // Add highlight for the mount line to make it clear
+                highlightLines: [mount.sourceContext.startLine, mount.sourceContext.endLine],
+                highlights: [{
+                  startLine: mount.sourceContext.startLine,
+                  endLine: mount.sourceContext.endLine,
+                  type: "return-success"
+                  // Use the success color (cyan) for the mount point
+                }]
+              };
+            }
+          }
+          expanded.push(...getExpandedRoutes(targetApp, nextPrefix, newSeen, nextSourceOverride));
+        }
+      }
+    }
+    return expanded;
+  };
+  applications.forEach((app) => {
+    astRoutes.push(...getExpandedRoutes(app));
+  });
+  const dedupedRoutes = /* @__PURE__ */ new Map();
+  for (const route of astRoutes) {
+    const key = `${route.method.toUpperCase()}:${route.path}`;
+    let score = 0;
+    if (route.responseSchema) score += 10;
+    if (route.handlerSource) score += 5;
+    if (!dedupedRoutes.has(key) || score > dedupedRoutes.get(key).score) {
+      dedupedRoutes.set(key, { route, score });
+    }
+  }
+  return Array.from(dedupedRoutes.values()).map((v) => v.route);
+}
 const REGEX_PATTERNS = {
   QUERY_INT: /parseInt\(ctx\.query\.(\w+)\)/g,
   QUERY_FLOAT: /parseFloat\(ctx\.query\.(\w+)\)/g,
@@ -998,90 +1102,43 @@ function analyzeHandler(handler) {
   }
   return { inferredSpec };
 }
-async function getAstRoutes$1(applications) {
-  const astRoutes = [];
-  const getExpandedRoutes = (app, prefix = "", seen = /* @__PURE__ */ new Set(), sourceOverride) => {
-    if (seen.has(app.name)) return [];
-    const newSeen = new Set(seen);
-    newSeen.add(app.name);
-    const expanded = [];
-    let currentPrefix = prefix;
-    if (app.controllerPrefix) {
-      const cleanPrefix = currentPrefix.endsWith("/") ? currentPrefix.slice(0, -1) : currentPrefix;
-      const cleanCont = app.controllerPrefix.startsWith("/") ? app.controllerPrefix : "/" + app.controllerPrefix;
-      currentPrefix = cleanPrefix + cleanCont;
-    }
-    for (const route of app.routes) {
-      const cleanPrefix = currentPrefix.endsWith("/") ? currentPrefix.slice(0, -1) : currentPrefix;
-      const cleanPath = route.path.startsWith("/") ? route.path : "/" + route.path;
-      let joined = cleanPrefix + cleanPath;
-      if (joined.length > 1 && joined.endsWith("/")) {
-        joined = joined.slice(0, -1);
-      }
-      const expandedRoute = {
-        ...route,
-        path: joined || "/"
-      };
-      if (sourceOverride) {
-        expandedRoute.sourceContext = sourceOverride;
-      }
-      expanded.push(expandedRoute);
-    }
-    if (app.mounted) {
-      for (const mount of app.mounted) {
-        const targetApp = applications.find((a) => a.name === mount.target || a.className === mount.target);
-        if (targetApp) {
-          const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-          const mountPrefix = mount.prefix.startsWith("/") ? mount.prefix : "/" + mount.prefix;
-          let nextSourceOverride = sourceOverride;
-          if (mount.dependency || mount.targetFilePath && mount.targetFilePath.includes("node_modules")) {
-            if (mount.sourceContext) {
-              nextSourceOverride = {
-                ...mount.sourceContext,
-                // Add highlight for the mount line to make it clear
-                highlightLines: [mount.sourceContext.startLine, mount.sourceContext.endLine],
-                highlights: [{
-                  startLine: mount.sourceContext.startLine,
-                  endLine: mount.sourceContext.endLine,
-                  type: "return-success"
-                  // Use the success color (cyan) for the mount point
-                }]
-              };
-            }
-          }
-          expanded.push(...getExpandedRoutes(targetApp, cleanPrefix + mountPrefix, newSeen, nextSourceOverride));
-        }
-      }
-    }
-    return expanded;
-  };
-  applications.forEach((app) => {
-    astRoutes.push(...getExpandedRoutes(app));
-  });
-  const dedupedRoutes = /* @__PURE__ */ new Map();
-  for (const route of astRoutes) {
-    const key = `${route.method.toUpperCase()}:${route.path}`;
-    let score = 0;
-    if (route.responseSchema) score += 10;
-    if (route.handlerSource) score += 5;
-    if (!dedupedRoutes.has(key) || score > dedupedRoutes.get(key).score) {
-      dedupedRoutes.set(key, { route, score });
-    }
-  }
-  return Array.from(dedupedRoutes.values()).map((v) => v.route);
-}
 async function generateOpenApi(rootRouter, options = {}) {
   const paths = {};
   const tagGroups = /* @__PURE__ */ new Map();
   const defaultTagGroup = options.defaultTagGroup || "General";
   const defaultTagName = options.defaultTag || "Application";
   let astRoutes = [];
+  let astMiddlewareRegistry = {};
+  let applications = [];
   try {
-    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-BqIe1p0R.js");
-    const analyzer = new OpenAPIAnalyzer2(process.cwd());
-    const { applications } = await analyzer.analyze();
-    astRoutes = await getAstRoutes$1(applications);
+    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-CnKnQ5KV.js");
+    const entrypoint = rootRouter.metadata?.file;
+    const analyzer = new OpenAPIAnalyzer2(process.cwd(), entrypoint);
+    const analysisResult = await analyzer.analyze();
+    applications = analysisResult.applications;
+    astRoutes = await getAstRoutes(applications);
+    let middlewareId = 0;
+    for (const app of applications) {
+      if (app.middleware && app.middleware.length > 0) {
+        for (const mw of app.middleware) {
+          const id = `middleware-${middlewareId++}`;
+          astMiddlewareRegistry[id] = {
+            ...mw,
+            id,
+            usedBy: []
+            // Will be populated when processing routes
+          };
+        }
+      }
+    }
   } catch (e) {
+    if (options.warnings) {
+      options.warnings.push({
+        type: "ast-analysis-failed",
+        message: "AST Analysis failed or skipped",
+        detail: e.message
+      });
+    }
   }
   const collect = (router, prefix = "", currentGroup = defaultTagGroup, defaultTag = defaultTagName, inheritedMiddleware = [], isRootLevel = true) => {
     let group = currentGroup;
@@ -1091,7 +1148,8 @@ async function generateOpenApi(rootRouter, options = {}) {
       tag = router.config.name;
     } else {
       const mountPath = router[$mountPath];
-      if (isRootLevel && mountPath && mountPath !== "/") {
+      const isDirectChild = router[$parent] === rootRouter;
+      if ((isRootLevel || isDirectChild) && mountPath && mountPath !== "/") {
         const segments = mountPath.split("/").filter(Boolean);
         if (segments.length > 0) {
           const lastSegment = segments[segments.length - 1];
@@ -1099,6 +1157,20 @@ async function generateOpenApi(rootRouter, options = {}) {
         }
       }
     }
+    let isBuiltinPlugin = false;
+    let pluginName = "";
+    if (router.metadata?.pluginName) {
+      isBuiltinPlugin = true;
+      pluginName = router.metadata.pluginName;
+      tag = pluginName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    } else if (router.metadata?.file && router.metadata.file.includes("plugins/application/")) {
+      isBuiltinPlugin = true;
+      const match = router.metadata.file.match(/plugins\/application\/([^/]+)/);
+      if (match) {
+        pluginName = match[1].replace(/\.(ts|js|mjs|mts|cjs)$/, "");
+        tag = pluginName.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+      }
+    }
     if (!tagGroups.has(group)) tagGroups.set(group, /* @__PURE__ */ new Set());
     const routerMiddleware = router.middleware || [];
     const routes = router[$routes] || [];
@@ -1121,11 +1193,45 @@ async function generateOpenApi(rootRouter, options = {}) {
       };
       const routeMiddleware = route.middleware || [];
       const allMiddleware = [...inheritedMiddleware, ...routerMiddleware, ...routeMiddleware];
-      if (allMiddleware.length > 0) {
-        operation["x-shokupan-middleware"] = allMiddleware.map((mw) => ({
-          name: mw.name || "middleware",
-          metadata: mw.metadata
-        }));
+      const astMiddlewareForRoute = [];
+      for (const [mwId, mw] of Object.entries(astMiddlewareRegistry)) {
+        const appForRoute = applications.find(
+          (app) => app.routes?.some((r) => r.path === fullPath && r.method === route.method.toUpperCase())
+        );
+        const appForMiddleware = applications.find(
+          (app) => app.middleware?.some((m) => m.name === mw.name && m.file === mw.file)
+        );
+        if (appForRoute && appForMiddleware && appForRoute.filePath === appForMiddleware.filePath) {
+          astMiddlewareForRoute.push({ ...mw, id: mwId });
+          if (!mw.usedBy.includes(fullPath)) {
+            mw.usedBy.push(fullPath);
+          }
+        }
+      }
+      for (const astMw of astMiddlewareForRoute) {
+        if (astMw.responseTypes) {
+          for (const [statusCode, responseSpec] of Object.entries(astMw.responseTypes)) {
+            if (!operation.responses[statusCode]) {
+              operation.responses[statusCode] = responseSpec;
+            }
+          }
+        }
+      }
+      if (allMiddleware.length > 0 || astMiddlewareForRoute.length > 0) {
+        operation["x-shokupan-middleware"] = [
+          ...allMiddleware.map((mw) => ({
+            name: mw.name || "middleware",
+            metadata: mw.metadata
+          })),
+          ...astMiddlewareForRoute.map((mw) => ({
+            id: mw.id,
+            name: mw.name,
+            responses: mw.responseTypes,
+            headers: mw.headers,
+            file: mw.file,
+            line: mw.startLine
+          }))
+        ];
       }
       if (route.guards) {
         for (const guard of route.guards) {
@@ -1191,6 +1297,18 @@ async function generateOpenApi(rootRouter, options = {}) {
             description: "Successful response",
             content: { "application/json": { schema: astMatch.responseSchema } }
           };
+          if (astMatch.hasUnknownFields) {
+            if (options.warnings) {
+              options.warnings.push({
+                type: "unknown-fields",
+                message: "Response contains fields with unknown types",
+                detail: `Route: ${fullPath} [${route.method}]`,
+                location: { file: astMatch.sourceContext?.file, line: astMatch.sourceContext?.startLine }
+              });
+            }
+            operation["x-warning"] = true;
+            operation["x-warning-reason"] = "Response contains fields with unknown types that could not be statically analyzed";
+          }
         } else if (astMatch.responseType) {
           let contentType = "application/json";
           if (astMatch.responseType === "string") contentType = "text/plain";
@@ -1210,6 +1328,14 @@ async function generateOpenApi(rootRouter, options = {}) {
           operation.parameters = params;
         }
       } else {
+        if (options.warnings) {
+          options.warnings.push({
+            type: "route-not-found",
+            message: "Route could not be statically analyzed",
+            detail: `Route: ${fullPath} [${route.method}]`,
+            location: route.metadata ? { file: route.metadata.file, line: route.metadata.line } : void 0
+          });
+        }
         const runtimeSource = (route.handler.originalHandler || route.handler).toString();
         let file;
         let line;
@@ -1226,10 +1352,22 @@ async function generateOpenApi(rootRouter, options = {}) {
           operation["x-shokupan-source"] = {
             file,
             line: line || 1,
-            code: runtimeSource
+            code: runtimeSource,
+            pluginName: route.handler.pluginName
+            // Inject pluginName from handler
           };
         }
       }
+      if (isBuiltinPlugin) {
+        operation["x-shokupan-builtin"] = true;
+      }
+      if (route.handler.pluginName) {
+        operation["x-shokupan-plugin-name"] = route.handler.pluginName;
+        if (!operation["x-shokupan-source"]) operation["x-shokupan-source"] = {};
+        operation["x-shokupan-source"].pluginName = route.handler.pluginName;
+      } else if (pluginName) {
+        operation["x-shokupan-plugin-name"] = pluginName;
+      }
       if (route.keys.length > 0) {
         const pathParams = route.keys.map((key) => ({
           name: key,
@@ -1306,7 +1444,46 @@ async function generateOpenApi(rootRouter, options = {}) {
   for (const [name, tags] of tagGroups.entries()) {
     xTagGroups.push({ name, tags: Array.from(tags).sort() });
   }
-  return {
+  if (!options.compliant) {
+    for (const [id, mw] of Object.entries(astMiddlewareRegistry || {})) {
+      const virtualPath = `/_middleware/${id}`;
+      paths[virtualPath] = {
+        get: {
+          tags: ["System", "Middleware"],
+          summary: `Middleware: ${mw.name}`,
+          description: `Virtual endpoint for middleware analysis.
+**File**: ${mw.file}
+**Line**: ${mw.startLine}`,
+          operationId: `getMiddleware_${id}`,
+          parameters: [],
+          responses: {
+            "200": {
+              description: "Middleware Analysis",
+              content: {
+                "application/json": {
+                  schema: { type: "object" }
+                }
+              }
+            }
+          },
+          "x-middleware-metadata": mw,
+          "x-virtual": true,
+          "x-middleware-detail": true,
+          "x-source-info": {
+            file: mw.file,
+            line: mw.startLine,
+            code: mw.snippet
+          },
+          "x-shokupan-source": {
+            file: mw.file,
+            line: mw.startLine,
+            code: mw.snippet
+          }
+        }
+      };
+    }
+  }
+  const spec = {
     openapi: "3.1.0",
     info: { title: "Shokupan API", version: "1.0.0", ...options.info },
     paths,
@@ -1314,8 +1491,29 @@ async function generateOpenApi(rootRouter, options = {}) {
     servers: options.servers,
     tags: options.tags,
     externalDocs: options.externalDocs,
-    "x-tagGroups": xTagGroups
+    "x-tagGroups": xTagGroups,
+    "x-middleware-registry": astMiddlewareRegistry
   };
+  if (options.compliant) {
+    spec["x-tagGroups"] = void 0;
+    spec["x-middleware-registry"] = void 0;
+    const stripExtensions = (obj) => {
+      if (!obj || typeof obj !== "object") return;
+      if (Array.isArray(obj)) {
+        obj.forEach(stripExtensions);
+        return;
+      }
+      for (const key of Object.keys(obj)) {
+        if (key.startsWith("x-")) {
+          delete obj[key];
+        } else {
+          stripExtensions(obj[key]);
+        }
+      }
+    };
+    stripExtensions(spec);
+  }
+  return spec;
 }
 const eta = new Eta();
 function serveStatic(config, prefix) {
@@ -1502,35 +1700,6 @@ function Inject(token) {
     });
   };
 }
-class HttpError extends Error {
-  status;
-  constructor(message, status) {
-    super(message);
-    this.name = "HttpError";
-    this.status = status;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, HttpError);
-    }
-  }
-}
-function getErrorStatus(err) {
-  if (!err || typeof err !== "object") {
-    return 500;
-  }
-  if (typeof err.status === "number") {
-    return err.status;
-  }
-  if (typeof err.statusCode === "number") {
-    return err.statusCode;
-  }
-  return 500;
-}
-class EventError extends HttpError {
-  constructor(message = "Event Error") {
-    super(message, 500);
-    this.name = "EventError";
-  }
-}
 const tracer = trace.getTracer("shokupan.middleware");
 function traceHandler(fn, name) {
   return async function(...args) {
@@ -1554,31 +1723,6 @@ function traceHandler(fn, name) {
     });
   };
 }
-class ShokupanRequestBase {
-  method;
-  url;
-  headers;
-  body;
-  async json() {
-    return JSON.parse(this.body);
-  }
-  async text() {
-    return this.body;
-  }
-  async formData() {
-    if (this.body instanceof FormData) {
-      return this.body;
-    }
-    return new Response(this.body, { headers: this.headers }).formData();
-  }
-  constructor(props) {
-    Object.assign(this, props);
-    if (!(this.headers instanceof Headers)) {
-      this.headers = new Headers(this.headers);
-    }
-  }
-}
-const ShokupanRequest = ShokupanRequestBase;
 function getCallerInfo(skipFrames = 1) {
   let file = "unknown";
   let line = 0;
@@ -1610,27 +1754,379 @@ function getCallerInfo(skipFrames = 1) {
   }
   return { file, line };
 }
-class RouterTrie {
-  root;
-  constructor() {
-    this.root = this.createNode();
-  }
-  createNode() {
-    return {
-      children: {}
-    };
-  }
-  insert(method, path, handler) {
-    let node = this.root;
-    const segments = this.splitPath(path);
-    for (let i = 0; i < segments.length; i++) {
-      const segment = segments[i];
-      if (segment === "**") {
-        if (!node.recursiveChild) {
-          node.recursiveChild = this.createNode();
-        }
-        node = node.recursiveChild;
-      } else if (segment === "*") {
+const HTTPMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "ALL"];
+var RouteParamType = /* @__PURE__ */ ((RouteParamType2) => {
+  RouteParamType2["BODY"] = "BODY";
+  RouteParamType2["PARAM"] = "PARAM";
+  RouteParamType2["QUERY"] = "QUERY";
+  RouteParamType2["HEADER"] = "HEADER";
+  RouteParamType2["REQUEST"] = "REQUEST";
+  RouteParamType2["CONTEXT"] = "CONTEXT";
+  return RouteParamType2;
+})(RouteParamType || {});
+class ControllerScanner {
+  static scan(router, prefix, controller) {
+    let instance = controller;
+    if (typeof controller === "function") {
+      instance = Container.resolve(controller);
+      const controllerPath = controller[$controllerPath];
+      if (controllerPath !== void 0) {
+        const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
+        prefix = p1 + p2;
+        if (!prefix) prefix = "/";
+      }
+    } else {
+      const ctor = instance.constructor;
+      const controllerPath = ctor[$controllerPath];
+      if (controllerPath !== void 0) {
+        const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
+        prefix = p1 + p2;
+        if (!prefix) prefix = "/";
+      }
+    }
+    instance[$mountPath] = prefix;
+    const info = getCallerInfo();
+    instance.metadata = {
+      file: info.file,
+      line: info.line,
+      name: instance.constructor.name
+    };
+    router.registerControllerInstance(instance);
+    const controllerMiddleware = (typeof controller === "function" ? controller[$middleware] : instance[$middleware]) || [];
+    const proto = Object.getPrototypeOf(instance);
+    const methods = /* @__PURE__ */ new Set();
+    let current = proto;
+    while (current !== void 0 && current !== Object.prototype) {
+      Object.getOwnPropertyNames(current).forEach((name) => methods.add(name));
+      current = Object.getPrototypeOf(current);
+    }
+    Object.getOwnPropertyNames(instance).forEach((name) => methods.add(name));
+    const decoratedRoutes = instance[$routeMethods] || proto && proto[$routeMethods];
+    const decoratedArgs = instance[$routeArgs] || proto && proto[$routeArgs];
+    const methodMiddlewareMap = instance[$middleware] || proto && proto[$middleware];
+    const decoratedEvents = instance[$eventMethods] || proto && proto[$eventMethods];
+    let routesAttached = 0;
+    for (let i = 0; i < Array.from(methods).length; i++) {
+      const name = Array.from(methods)[i];
+      if (name === "constructor") continue;
+      if (["arguments", "caller", "callee"].includes(name)) continue;
+      const originalHandler = instance[name];
+      if (typeof originalHandler !== "function") continue;
+      let method;
+      let subPath = "";
+      let methodSource;
+      const routeConfig = decoratedRoutes?.get(name);
+      if (routeConfig !== void 0) {
+        method = routeConfig.method;
+        subPath = routeConfig.path;
+        methodSource = routeConfig.source;
+      } else {
+        for (let j = 0; j < HTTPMethods.length; j++) {
+          const m = HTTPMethods[j];
+          if (name.toUpperCase().startsWith(m)) {
+            method = m;
+            const rest = name.slice(m.length);
+            if (rest.length === 0) {
+              subPath = "/";
+            } else {
+              subPath = "";
+              let buffer = "";
+              const flush = () => {
+                if (buffer.length > 0) {
+                  subPath += "/" + buffer.toLowerCase();
+                  buffer = "";
+                }
+              };
+              for (let i2 = 0; i2 < rest.length; i2++) {
+                const char = rest[i2];
+                if (char === "$") {
+                  flush();
+                  subPath += "/:";
+                  continue;
+                }
+                buffer += char;
+              }
+              if (buffer.length > 0) flush();
+              subPath = rest.replace(/\$/g, "/:").replace(/([a-z0-9])([A-Z])/g, "$1/$2").toLowerCase();
+              if (!subPath.startsWith("/")) {
+                subPath = "/" + subPath;
+              }
+            }
+            break;
+          }
+        }
+      }
+      if (method !== void 0 && method !== "") {
+        routesAttached++;
+        const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        const cleanSubPath = subPath === "/" ? "" : subPath;
+        let joined;
+        if (cleanSubPath.length === 0) {
+          joined = cleanPrefix;
+        } else if (cleanSubPath.startsWith("/")) {
+          joined = cleanPrefix + cleanSubPath;
+        } else {
+          joined = cleanPrefix + "/" + cleanSubPath;
+        }
+        const fullPath = joined || "/";
+        const normalizedPath = fullPath.replace(/\/+/g, "/");
+        const methodMw = methodMiddlewareMap instanceof Map ? methodMiddlewareMap.get(name) || [] : [];
+        const allMiddleware = [...controllerMiddleware, ...methodMw];
+        const routeArgs = decoratedArgs && decoratedArgs.get(name);
+        const wrappedHandler = async (ctx) => {
+          let args = [ctx];
+          if (routeArgs?.length > 0) {
+            args = [];
+            const sortedArgs = [...routeArgs].sort((a, b) => a.index - b.index);
+            for (let k = 0; k < sortedArgs.length; k++) {
+              const arg = sortedArgs[k];
+              switch (arg.type) {
+                case RouteParamType.BODY:
+                  args[arg.index] = await ctx.body();
+                  break;
+                case RouteParamType.PARAM:
+                  args[arg.index] = arg.name ? ctx.params[arg.name] : ctx.params;
+                  break;
+                case RouteParamType.QUERY: {
+                  const url = new URL(ctx.req.url);
+                  if (arg.name) {
+                    const vals = url.searchParams.getAll(arg.name);
+                    args[arg.index] = vals.length > 1 ? vals : vals[0];
+                  } else {
+                    const query = {};
+                    const keys = Object.keys(url.searchParams);
+                    for (let k2 = 0; k2 < keys.length; k2++) {
+                      const key = keys[k2];
+                      const vals = url.searchParams.getAll(key);
+                      query[key] = vals.length > 1 ? vals : vals[0];
+                    }
+                    args[arg.index] = query;
+                  }
+                  break;
+                }
+                case RouteParamType.HEADER:
+                  args[arg.index] = arg.name ? ctx.req.headers.get(arg.name) : ctx.req.headers;
+                  break;
+                case RouteParamType.REQUEST:
+                  args[arg.index] = ctx.req;
+                  break;
+                case RouteParamType.CONTEXT:
+                  args[arg.index] = ctx;
+                  break;
+              }
+            }
+          }
+          const tracedOriginalHandler = ctx.app?.applicationConfig.enableTracing ? traceHandler(originalHandler, normalizedPath) : originalHandler;
+          return tracedOriginalHandler.apply(instance, args);
+        };
+        let finalHandler = wrappedHandler;
+        if (allMiddleware.length > 0) {
+          const composed = compose(allMiddleware);
+          finalHandler = async (ctx) => {
+            return composed(ctx, () => wrappedHandler(ctx));
+          };
+        }
+        finalHandler.originalHandler = originalHandler;
+        if (finalHandler !== wrappedHandler) {
+          wrappedHandler.originalHandler = originalHandler;
+        }
+        const tagName = instance.constructor.name;
+        const decoratedSpecs = instance[$routeSpec] || proto && proto[$routeSpec];
+        const userSpec = decoratedSpecs && decoratedSpecs.get(name);
+        const spec = { tags: [tagName], ...userSpec };
+        router.add({
+          method,
+          path: normalizedPath,
+          handler: finalHandler,
+          spec,
+          controller: instance,
+          metadata: methodSource || instance.metadata,
+          middleware: allMiddleware
+        });
+      }
+      const eventConfig = decoratedEvents?.get(name);
+      if (eventConfig !== void 0) {
+        routesAttached++;
+        const routeArgs = decoratedArgs?.get(name);
+        const wrappedHandler = async (ctx) => {
+          let args = [ctx];
+          if (routeArgs?.length > 0) {
+            args = [];
+            const sortedArgs = [...routeArgs].sort((a, b) => a.index - b.index);
+            for (let k = 0; k < sortedArgs.length; k++) {
+              const arg = sortedArgs[k];
+              switch (arg.type) {
+                case RouteParamType.BODY:
+                  args[arg.index] = await ctx.body();
+                  break;
+                case RouteParamType.CONTEXT:
+                  args[arg.index] = ctx;
+                  break;
+                case RouteParamType.REQUEST:
+                  args[arg.index] = ctx.req;
+                  break;
+                case RouteParamType.HEADER:
+                  args[arg.index] = arg.name ? ctx.req.headers.get(arg.name) : ctx.req.headers;
+                  break;
+                default:
+                  args[arg.index] = void 0;
+              }
+            }
+          }
+          return originalHandler.apply(instance, args);
+        };
+        const decoratedSpecs = instance[$routeSpec] || proto && proto[$routeSpec];
+        const userSpec = decoratedSpecs && decoratedSpecs.get(name);
+        const spec = { tags: [{ name: instance.constructor.name }], ...userSpec };
+        wrappedHandler.spec = spec;
+        wrappedHandler.originalHandler = originalHandler;
+        router.event(eventConfig.eventName, wrappedHandler);
+      }
+    }
+    if (routesAttached === 0) {
+      console.warn(`No routes attached to controller ${instance.constructor.name}`);
+    }
+    instance[$isMounted] = true;
+  }
+}
+class HttpError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, HttpError);
+    }
+  }
+}
+function getErrorStatus(err) {
+  if (!err || typeof err !== "object") {
+    return 500;
+  }
+  if (typeof err.status === "number") {
+    return err.status;
+  }
+  if (typeof err.statusCode === "number") {
+    return err.statusCode;
+  }
+  return 500;
+}
+class EventError extends HttpError {
+  constructor(message = "Event Error") {
+    super(message, 500);
+    this.name = "EventError";
+  }
+}
+class MiddlewareTracker {
+  static wrap(handler, context2) {
+    const { file, line, name, isBuiltin, pluginName } = context2;
+    const handlerName = name || handler.name || "anonymous";
+    const trackedHandler = async (ctx, next) => {
+      if (!ctx.app?.applicationConfig.enableMiddlewareTracking) {
+        return handler(ctx, next);
+      }
+      const startTime = performance.now();
+      let error = void 0;
+      try {
+        ctx.handlerStack.push({
+          name: handlerName,
+          file,
+          line,
+          isBuiltin,
+          startTime,
+          duration: -1
+        });
+        return await handler(ctx, next);
+      } catch (e) {
+        error = e;
+        throw e;
+      } finally {
+        const duration = performance.now() - startTime;
+        const stackItem = ctx.handlerStack[ctx.handlerStack.length - 1];
+        if (stackItem && stackItem.name === handlerName) {
+          stackItem.duration = duration;
+        }
+        Promise.resolve().then(async () => {
+          try {
+            const db = ctx.app?.db;
+            if (!db) return;
+            const timestamp = Date.now();
+            await db.upsert(new RecordId("middleware_tracking", {
+              timestamp,
+              name: handlerName
+            }), {
+              name: handlerName,
+              path: ctx.path,
+              timestamp,
+              duration,
+              file,
+              line,
+              error: error ? String(error) : void 0,
+              metadata: {
+                isBuiltin,
+                pluginName
+              }
+            });
+          } catch (err) {
+          }
+        });
+      }
+    };
+    trackedHandler.metadata = handler.metadata || context2;
+    Object.defineProperty(trackedHandler, "name", { value: handlerName });
+    trackedHandler.originalHandler = handler.originalHandler || handler;
+    return trackedHandler;
+  }
+}
+class ShokupanRequestBase {
+  method;
+  url;
+  headers;
+  body;
+  async json() {
+    return JSON.parse(this.body);
+  }
+  async text() {
+    return this.body;
+  }
+  async formData() {
+    if (this.body instanceof FormData) {
+      return this.body;
+    }
+    return new Response(this.body, { headers: this.headers }).formData();
+  }
+  constructor(props) {
+    Object.assign(this, props);
+    if (!(this.headers instanceof Headers)) {
+      this.headers = new Headers(this.headers);
+    }
+  }
+}
+const ShokupanRequest = ShokupanRequestBase;
+class RouterTrie {
+  root;
+  constructor() {
+    this.root = this.createNode();
+  }
+  createNode() {
+    return {
+      children: {}
+    };
+  }
+  insert(method, path, handler) {
+    let node = this.root;
+    const segments = this.splitPath(path);
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      if (segment === "**") {
+        if (!node.recursiveChild) {
+          node.recursiveChild = this.createNode();
+        }
+        node = node.recursiveChild;
+      } else if (segment === "*") {
         if (!node.wildcardChild) {
           node.wildcardChild = this.createNode();
         }
@@ -1707,19 +2203,9 @@ class RouterTrie {
     if (path === "/" || path === "") return [];
     const s = path.startsWith("/") ? path.slice(1) : path;
     if (s === "") return [];
-    return s.split("/");
-  }
-}
-const HTTPMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "ALL"];
-var RouteParamType = /* @__PURE__ */ ((RouteParamType2) => {
-  RouteParamType2["BODY"] = "BODY";
-  RouteParamType2["PARAM"] = "PARAM";
-  RouteParamType2["QUERY"] = "QUERY";
-  RouteParamType2["HEADER"] = "HEADER";
-  RouteParamType2["REQUEST"] = "REQUEST";
-  RouteParamType2["CONTEXT"] = "CONTEXT";
-  return RouteParamType2;
-})(RouteParamType || {});
+    return s.split("/");
+  }
+}
 const RouterRegistry = /* @__PURE__ */ new Map();
 const ShokupanApplicationTree = {};
 class ShokupanRouter {
@@ -1728,6 +2214,9 @@ class ShokupanRouter {
     if (config?.requestTimeout) {
       this.requestTimeout = config.requestTimeout;
     }
+    if (config?.hooks) {
+      this.ensureHooksInitialized();
+    }
   }
   // Internal marker to identify Router vs. Application
   [$isApplication] = false;
@@ -1739,6 +2228,47 @@ class ShokupanRouter {
   [$parent] = null;
   [$childRouters] = [];
   [$childControllers] = [];
+  _hasOnResponseEndHook;
+  _hasOnRequestStartHook;
+  _hasOnRequestEndHook;
+  _hasOnResponseStartHook;
+  _hasOnErrorHook;
+  _hasOnRequestTimeoutHook;
+  _hasOnReadTimeoutHook;
+  _hasOnWriteTimeoutHook;
+  _hasBeforeValidateHook;
+  _hasAfterValidateHook;
+  get hasOnResponseEndHook() {
+    return this._hasOnResponseEndHook;
+  }
+  get hasOnRequestStartHook() {
+    return this._hasOnRequestStartHook;
+  }
+  get hasOnRequestEndHook() {
+    return this._hasOnRequestEndHook;
+  }
+  get hasOnResponseStartHook() {
+    return this._hasOnResponseStartHook;
+  }
+  get hasOnErrorHook() {
+    return this._hasOnErrorHook;
+  }
+  get hasOnRequestTimeoutHook() {
+    return this._hasOnRequestTimeoutHook;
+  }
+  get hasOnReadTimeoutHook() {
+    return this._hasOnReadTimeoutHook;
+  }
+  get hasOnWriteTimeoutHook() {
+    return this._hasOnWriteTimeoutHook;
+  }
+  get hasBeforeValidateHook() {
+    return this._hasBeforeValidateHook;
+  }
+  get hasAfterValidateHook() {
+    return this._hasAfterValidateHook;
+  }
+  requestTimeout;
   get db() {
     return this.root?.db;
   }
@@ -1774,7 +2304,7 @@ class ShokupanRouter {
       const r = this[$routes][i];
       const entry = {
         type: "route",
-        path: r.path,
+        path: r.path.startsWith("/") ? r.path : "/" + r.path,
         method: r.method,
         metadata: r.metadata,
         handlerName: r.handler.name,
@@ -1801,7 +2331,7 @@ class ShokupanRouter {
     })) : [];
     const routers = this[$childRouters].map((r) => ({
       type: "router",
-      path: r[$mountPath],
+      path: r[$mountPath].startsWith("/") ? r[$mountPath] : "/" + r[$mountPath],
       metadata: r.metadata,
       children: r.getComponentRegistry()
     }));
@@ -1815,12 +2345,25 @@ class ShokupanRouter {
         children: { routes }
       };
     });
+    const events = [];
+    this.eventHandlers.forEach((handlers, name) => {
+      handlers.forEach((h) => {
+        events.push({
+          type: "event",
+          name,
+          handlerName: h.name,
+          metadata: h.source ? { file: h.source.file, line: h.source.line } : void 0,
+          _fn: h
+        });
+      });
+    });
     return {
       metadata: this.metadata,
       middleware,
       routes: localRoutes,
       routers,
-      controllers
+      controllers,
+      events
     };
   }
   isRouterInstance(target) {
@@ -1843,12 +2386,38 @@ class ShokupanRouter {
     }
     return this;
   }
+  /**
+   * Registers a lifecycle hook dynamically.
+   */
+  hook(name, handler) {
+    if (!this.hooksInitialized) {
+      this.ensureHooksInitialized();
+    }
+    let handlers = this.hookCache.get(name);
+    if (!handlers) {
+      handlers = [];
+      this.hookCache.set(name, handlers);
+      this._hasOnErrorHook ||= name === "onError";
+      this._hasOnRequestStartHook ||= name === "onRequestStart";
+      this._hasOnRequestEndHook ||= name === "onRequestEnd";
+      this._hasOnResponseStartHook ||= name === "onResponseStart";
+      this._hasOnResponseEndHook ||= name === "onResponseEnd";
+      this._hasOnRequestTimeoutHook ||= name === "onRequestTimeout";
+      this._hasOnReadTimeoutHook ||= name === "onReadTimeout";
+      this._hasOnWriteTimeoutHook ||= name === "onWriteTimeout";
+      this._hasBeforeValidateHook ||= name === "beforeValidate";
+      this._hasAfterValidateHook ||= name === "afterValidate";
+    }
+    handlers.push(handler);
+    return this;
+  }
   /**
    * Finds an event handler(s) by name.
    */
   findEvent(name) {
-    if (this.eventHandlers.has(name)) {
-      return this.eventHandlers.get(name);
+    const handlers = this.eventHandlers.get(name);
+    if (handlers !== void 0) {
+      return handlers;
     }
     for (const child of this[$childRouters]) {
       const handler = child.findEvent(name);
@@ -1856,6 +2425,12 @@ class ShokupanRouter {
     }
     return null;
   }
+  /**
+   * Registers a controller instance to the router.
+   */
+  registerControllerInstance(controller) {
+    this[$childControllers].push(controller);
+  }
   /**
    * Returns all registered event handlers.
    */
@@ -1882,7 +2457,7 @@ class ShokupanRouter {
     if (this.isRouterInstance(controller)) {
       this.mountRouter(prefix, controller);
     } else {
-      this.scanControllerRoutes(prefix, controller);
+      ControllerScanner.scan(this, prefix, controller);
     }
     return this;
   }
@@ -2036,264 +2611,23 @@ class ShokupanRouter {
       throw new Error("Router is already mounted");
     }
     router[$mountPath] = prefix;
-    if (!router.metadata) {
-      const info = getCallerInfo();
-      router.metadata = {
-        file: info.file,
-        line: info.line,
-        name: "MountedRouter"
-      };
-    }
-    this[$childRouters].push(router);
-    router[$parent] = this;
-    const setRouterContext = (router2) => {
-      router2[$appRoot] = this.root;
-      router2[$childRouters].forEach((child) => setRouterContext(child));
-    };
-    setRouterContext(router);
-    router[$appRoot] = this.root;
-    router[$isMounted] = true;
-  }
-  scanControllerRoutes(prefix, controller) {
-    let instance = controller;
-    if (typeof controller === "function") {
-      instance = Container.resolve(controller);
-      const controllerPath = controller[$controllerPath];
-      if (controllerPath) {
-        const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-        const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
-        prefix = p1 + p2;
-        if (!prefix) prefix = "/";
-      }
-    } else {
-      const ctor = instance.constructor;
-      const controllerPath = ctor[$controllerPath];
-      if (controllerPath) {
-        const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-        const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
-        prefix = p1 + p2;
-        if (!prefix) prefix = "/";
-      }
-    }
-    instance[$mountPath] = prefix;
-    const info = getCallerInfo();
-    instance.metadata = {
-      file: info.file,
-      line: info.line,
-      name: instance.constructor.name
-    };
-    this[$childControllers].push(instance);
-    const controllerMiddleware = (typeof controller === "function" ? controller[$middleware] : instance[$middleware]) || [];
-    const proto = Object.getPrototypeOf(instance);
-    const methods = /* @__PURE__ */ new Set();
-    let current = proto;
-    while (current && current !== Object.prototype) {
-      Object.getOwnPropertyNames(current).forEach((name) => methods.add(name));
-      current = Object.getPrototypeOf(current);
-    }
-    Object.getOwnPropertyNames(instance).forEach((name) => methods.add(name));
-    const decoratedRoutes = instance[$routeMethods] || proto && proto[$routeMethods];
-    const decoratedArgs = instance[$routeArgs] || proto && proto[$routeArgs];
-    const methodMiddlewareMap = instance[$middleware] || proto && proto[$middleware];
-    const decoratedEvents = instance[$eventMethods] || proto && proto[$eventMethods];
-    let routesAttached = 0;
-    for (let i = 0; i < Array.from(methods).length; i++) {
-      const name = Array.from(methods)[i];
-      if (name === "constructor") continue;
-      if (["arguments", "caller", "callee"].includes(name)) continue;
-      const originalHandler = instance[name];
-      if (typeof originalHandler !== "function") continue;
-      let method;
-      let subPath = "";
-      let methodSource;
-      if (decoratedRoutes && decoratedRoutes.has(name)) {
-        const config = decoratedRoutes.get(name);
-        method = config.method;
-        subPath = config.path;
-        methodSource = config.source;
-      } else {
-        for (let j = 0; j < HTTPMethods.length; j++) {
-          const m = HTTPMethods[j];
-          if (name.toUpperCase().startsWith(m)) {
-            method = m;
-            const rest = name.slice(m.length);
-            if (rest.length === 0) {
-              subPath = "/";
-            } else {
-              subPath = "";
-              let buffer = "";
-              const flush = () => {
-                if (buffer.length > 0) {
-                  subPath += "/" + buffer.toLowerCase();
-                  buffer = "";
-                }
-              };
-              for (let i2 = 0; i2 < rest.length; i2++) {
-                const char = rest[i2];
-                if (char === "$") {
-                  flush();
-                  subPath += "/:";
-                  continue;
-                }
-                buffer += char;
-              }
-              if (buffer.length > 0) flush();
-              subPath = rest.replace(/\$/g, "/:").replace(/([a-z0-9])([A-Z])/g, "$1/$2").toLowerCase();
-              if (!subPath.startsWith("/")) {
-                subPath = "/" + subPath;
-              }
-            }
-            break;
-          }
-        }
-      }
-      if (method) {
-        routesAttached++;
-        const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-        const cleanSubPath = subPath === "/" ? "" : subPath;
-        let joined;
-        if (cleanSubPath.length === 0) {
-          joined = cleanPrefix;
-        } else if (cleanSubPath.startsWith("/")) {
-          joined = cleanPrefix + cleanSubPath;
-        } else {
-          joined = cleanPrefix + "/" + cleanSubPath;
-        }
-        const fullPath = joined || "/";
-        const normalizedPath = fullPath.replace(/\/+/g, "/");
-        const methodMw = methodMiddlewareMap instanceof Map ? methodMiddlewareMap.get(name) || [] : [];
-        const allMiddleware = [...controllerMiddleware, ...methodMw];
-        const routeArgs = decoratedArgs && decoratedArgs.get(name);
-        const wrappedHandler = async (ctx) => {
-          let args = [ctx];
-          if (routeArgs?.length > 0) {
-            args = [];
-            const sortedArgs = [...routeArgs].sort((a, b) => a.index - b.index);
-            for (let k = 0; k < sortedArgs.length; k++) {
-              const arg = sortedArgs[k];
-              switch (arg.type) {
-                case RouteParamType.BODY:
-                  try {
-                    if (ctx.req.headers.get("content-type")?.includes("application/json")) {
-                      args[arg.index] = await ctx.req.json();
-                    } else {
-                      const text = await ctx.req.text();
-                      if (!text) {
-                        args[arg.index] = {};
-                      } else {
-                        args[arg.index] = JSON.parse(text);
-                      }
-                    }
-                  } catch (e) {
-                    const err = new Error("Invalid JSON body");
-                    err.status = 400;
-                    throw err;
-                  }
-                  break;
-                case RouteParamType.PARAM:
-                  args[arg.index] = arg.name ? ctx.params[arg.name] : ctx.params;
-                  break;
-                case RouteParamType.QUERY: {
-                  const url = new URL(ctx.req.url);
-                  if (arg.name) {
-                    const vals = url.searchParams.getAll(arg.name);
-                    args[arg.index] = vals.length > 1 ? vals : vals[0];
-                  } else {
-                    const query = {};
-                    const keys = Object.keys(url.searchParams);
-                    for (let k2 = 0; k2 < keys.length; k2++) {
-                      const key = keys[k2];
-                      const vals = url.searchParams.getAll(key);
-                      query[key] = vals.length > 1 ? vals : vals[0];
-                    }
-                    args[arg.index] = query;
-                  }
-                  break;
-                }
-                case RouteParamType.HEADER:
-                  args[arg.index] = arg.name ? ctx.req.headers.get(arg.name) : ctx.req.headers;
-                  break;
-                case RouteParamType.REQUEST:
-                  args[arg.index] = ctx.req;
-                  break;
-                case RouteParamType.CONTEXT:
-                  args[arg.index] = ctx;
-                  break;
-              }
-            }
-          }
-          const tracedOriginalHandler = ctx.app?.applicationConfig.enableTracing ? traceHandler(originalHandler, normalizedPath) : originalHandler;
-          return tracedOriginalHandler.apply(instance, args);
-        };
-        let finalHandler = wrappedHandler;
-        if (allMiddleware.length > 0) {
-          const composed = compose(allMiddleware);
-          finalHandler = async (ctx) => {
-            return composed(ctx, () => wrappedHandler(ctx));
-          };
-        }
-        finalHandler.originalHandler = originalHandler;
-        if (finalHandler !== wrappedHandler) {
-          wrappedHandler.originalHandler = originalHandler;
-        }
-        const tagName = instance.constructor.name;
-        const decoratedSpecs = instance[$routeSpec] || proto && proto[$routeSpec];
-        const userSpec = decoratedSpecs && decoratedSpecs.get(name);
-        const spec = { tags: [tagName], ...userSpec };
-        this.add({
-          method,
-          path: normalizedPath,
-          handler: finalHandler,
-          spec,
-          controller: instance,
-          metadata: methodSource || instance.metadata,
-          middleware: allMiddleware
-          // Capture all resolved middleware
-        });
-      }
-      if (decoratedEvents?.has(name)) {
-        routesAttached++;
-        const config = decoratedEvents.get(name);
-        const routeArgs = decoratedArgs?.get(name);
-        const wrappedHandler = async (ctx) => {
-          let args = [ctx];
-          if (routeArgs?.length > 0) {
-            args = [];
-            const sortedArgs = [...routeArgs].sort((a, b) => a.index - b.index);
-            for (let k = 0; k < sortedArgs.length; k++) {
-              const arg = sortedArgs[k];
-              switch (arg.type) {
-                case RouteParamType.BODY:
-                  args[arg.index] = await ctx.body();
-                  break;
-                case RouteParamType.CONTEXT:
-                  args[arg.index] = ctx;
-                  break;
-                case RouteParamType.REQUEST:
-                  args[arg.index] = ctx.req;
-                  break;
-                case RouteParamType.HEADER:
-                  args[arg.index] = arg.name ? ctx.req.headers.get(arg.name) : ctx.req.headers;
-                  break;
-                default:
-                  args[arg.index] = void 0;
-              }
-            }
-          }
-          return originalHandler.apply(instance, args);
-        };
-        const decoratedSpecs = instance[$routeSpec] || proto && proto[$routeSpec];
-        const userSpec = decoratedSpecs && decoratedSpecs.get(name);
-        const spec = { tags: [{ name: instance.constructor.name }], ...userSpec };
-        wrappedHandler.spec = spec;
-        wrappedHandler.originalHandler = originalHandler;
-        this.event(config.eventName, wrappedHandler);
-      }
-    }
-    if (routesAttached === 0) {
-      console.warn(`No routes attached to controller ${instance.constructor.name}`);
+    if (!router.metadata) {
+      const info = getCallerInfo();
+      router.metadata = {
+        file: info.file,
+        line: info.line,
+        name: "MountedRouter"
+      };
     }
-    instance[$isMounted] = true;
+    this[$childRouters].push(router);
+    router[$parent] = this;
+    const setRouterContext = (router2) => {
+      router2[$appRoot] = this.root;
+      router2[$childRouters].forEach((child) => setRouterContext(child));
+    };
+    setRouterContext(router);
+    router[$appRoot] = this.root;
+    router[$isMounted] = true;
   }
   /**
    * Find a route matching the given method and path.
@@ -2327,6 +2661,9 @@ class ShokupanRouter {
     return null;
   }
   parsePath(path) {
+    if (typeof path !== "string") {
+      throw new Error(`Route path must be a string or regexp, received ${typeof path == "function" ? path["name"] || path["constructor"]?.["name"] || "function" : typeof path}. Dynamic paths are **highly** discouraged.`);
+    }
     const keys = [];
     if (path.length > 2048) {
       throw new Error("Path too long");
@@ -2340,8 +2677,6 @@ class ShokupanRouter {
       keys
     };
   }
-  // --- Functional Routing ---
-  requestTimeout;
   /**
    * Adds a route to the router.
    * 
@@ -2375,9 +2710,6 @@ class ShokupanRouter {
       }
     }
     let wrappedHandler = async (ctx) => {
-      if (ctx.upgrade()) {
-        return void 0;
-      }
       return handler(ctx);
     };
     wrappedHandler.originalHandler = handler.originalHandler || handler;
@@ -2432,67 +2764,13 @@ class ShokupanRouter {
       };
     }
     const { file, line } = metadata || getCallerInfo();
-    const trackingHandler = wrappedHandler;
-    wrappedHandler = async (ctx) => {
-      if (!ctx.app?.applicationConfig.enableMiddlewareTracking) {
-        return trackingHandler(ctx);
-      }
-      const startTime = performance.now();
-      let error = void 0;
-      try {
-        if (ctx.app?.applicationConfig.enableMiddlewareTracking) {
-          ctx.handlerStack.push({
-            name: handler.name || "anonymous",
-            file,
-            line
-          });
-        }
-        return await trackingHandler(ctx);
-      } catch (e) {
-        error = e;
-        throw e;
-      } finally {
-        if (ctx.app?.applicationConfig.enableMiddlewareTracking) {
-          const duration = performance.now() - startTime;
-          const config = ctx.app.applicationConfig;
-          Promise.resolve().then(async () => {
-            try {
-              const db = ctx.app?.db;
-              if (!db) return;
-              const timestamp = Date.now();
-              await db.upsert(new RecordId("middleware_tracking", {
-                timestamp,
-                name: handler.name || "anonymous"
-              }), {
-                name: handler.name || "anonymous",
-                path: ctx.path,
-                timestamp,
-                duration,
-                file,
-                line,
-                error: error ? String(error) : void 0,
-                metadata: {
-                  isBuiltin: handler.isBuiltin,
-                  pluginName: handler.pluginName
-                }
-              });
-              const ttl = config.middlewareTrackingTTL ?? 864e5;
-              const maxCapacity = config.middlewareTrackingMaxCapacity ?? 1e4;
-              const cutoff = Date.now() - ttl;
-              await db.query(`DELETE middleware_tracking WHERE timestamp < ${cutoff}`);
-              const results = await db.query("SELECT count() FROM middleware_tracking GROUP ALL");
-              if (results?.[0]?.count > maxCapacity) {
-                const toDelete = results[0].count - maxCapacity;
-                await db.query(`DELETE middleware_tracking ORDER BY timestamp ASC LIMIT ${toDelete}`);
-              }
-            } catch (datastoreError) {
-              console.error("Failed to store middleware tracking:", datastoreError);
-            }
-          });
-        }
-      }
-    };
-    wrappedHandler.originalHandler = trackingHandler.originalHandler || trackingHandler;
+    wrappedHandler = MiddlewareTracker.wrap(wrappedHandler, {
+      file,
+      line,
+      name: handler.name || "anonymous",
+      isBuiltin: handler.isBuiltin,
+      pluginName: handler.pluginName
+    });
     let bakedHandler = wrappedHandler;
     if (this.config?.hooks) {
       bakedHandler = this.wrapWithHooks(wrappedHandler);
@@ -2567,17 +2845,11 @@ class ShokupanRouter {
       }
     } catch (e) {
     }
-    const trackedGuard = async (ctx, next) => {
-      if (ctx.app?.applicationConfig.enableMiddlewareTracking) {
-        ctx.handlerStack.push({
-          name: guardHandler.name || "guard",
-          file,
-          line
-        });
-      }
-      return guardHandler(ctx, next);
-    };
-    trackedGuard.originalHandler = guardHandler.originalHandler ?? guardHandler;
+    const trackedGuard = MiddlewareTracker.wrap(guardHandler, {
+      file,
+      line,
+      name: guardHandler.name || "guard"
+    });
     this.currentGuards.push({ handler: trackedGuard, spec });
     return this;
   }
@@ -2606,113 +2878,376 @@ class ShokupanRouter {
       description: "Serves static files from " + normalizedPrefix,
       tags: [groupName]
     };
-    const spec = config.openapi ? config.openapi : defaultSpec;
-    if (!spec.tags) spec.tags = [groupName];
-    else if (!spec.tags.includes(groupName)) spec.tags.push(groupName);
-    const pattern = `^${normalizedPrefix}(/.*)?$`;
-    const regex = new RegExp(pattern);
-    const displayPath = normalizedPrefix === "/" ? "/*" : normalizedPrefix + "/*";
-    this.add({ method: "GET", path: displayPath, handler: routeHandler, spec, regex });
-    this.add({ method: "HEAD", path: displayPath, handler: routeHandler, spec, regex });
-    return this;
+    const spec = config.openapi ? config.openapi : defaultSpec;
+    if (!spec.tags) spec.tags = [groupName];
+    else if (!spec.tags.includes(groupName)) spec.tags.push(groupName);
+    const pattern = `^${normalizedPrefix}(/.*)?$`;
+    const regex = new RegExp(pattern);
+    const displayPath = normalizedPrefix === "/" ? "/*" : normalizedPrefix + "/*";
+    this.add({ method: "GET", path: displayPath, handler: routeHandler, spec, regex });
+    this.add({ method: "HEAD", path: displayPath, handler: routeHandler, spec, regex });
+    return this;
+  }
+  /**
+   * Attach the verb routes with their overload signatures.
+   * Use compose to handle multiple handlers (middleware).
+   */
+  attachVerb(method, path, ...args) {
+    let spec;
+    let handlers = [];
+    if (args.length > 0) {
+      if (typeof args[0] === "object" && args[0] !== null) {
+        spec = args[0];
+        handlers = args.slice(1);
+      } else {
+        handlers = args;
+      }
+    }
+    if (handlers.length === 0) {
+      return;
+    }
+    let finalHandler = handlers[handlers.length - 1];
+    if (handlers.length > 1) {
+      const fn = compose(handlers);
+      finalHandler = (ctx) => fn(ctx);
+    }
+    this.add({
+      method,
+      path,
+      spec,
+      handler: finalHandler,
+      middleware: handlers.slice(0, handlers.length - 1)
+    });
+  }
+  /**
+   * Generates an OpenAPI 3.1 Document by recursing through the router and its descendants.
+   * Now includes runtime analysis of handler functions to infer request/response types.
+   */
+  generateApiSpec(options = {}) {
+    return generateOpenApi(this, options);
+  }
+  hasHooks(name) {
+    if (!this.hooksInitialized) {
+      this.ensureHooksInitialized();
+    }
+    const hooks = this.hookCache.get(name);
+    return hooks !== void 0 && hooks.length > 0;
+  }
+  ensureHooksInitialized() {
+    const hooks = this.config?.hooks;
+    if (hooks) {
+      const hookList = Array.isArray(hooks) ? hooks : [hooks];
+      const hookTypes = [
+        "onRequestStart",
+        "onRequestEnd",
+        "onResponseStart",
+        "onResponseEnd",
+        "onError",
+        "beforeValidate",
+        "afterValidate",
+        "onRequestTimeout",
+        "onReadTimeout",
+        "onWriteTimeout"
+      ];
+      for (let i = 0; i < hookTypes.length; i++) {
+        const type = hookTypes[i];
+        const fns = [];
+        for (let j = 0; j < hookList.length; j++) {
+          const h = hookList[j];
+          if (h[type]) fns.push(h[type]);
+        }
+        if (fns.length > 0) {
+          this._hasOnErrorHook ||= type === "onError";
+          this._hasOnRequestStartHook ||= type === "onRequestStart";
+          this._hasOnRequestEndHook ||= type === "onRequestEnd";
+          this._hasOnResponseStartHook ||= type === "onResponseStart";
+          this._hasOnResponseEndHook ||= type === "onResponseEnd";
+          this._hasOnRequestTimeoutHook ||= type === "onRequestTimeout";
+          this._hasOnReadTimeoutHook ||= type === "onReadTimeout";
+          this._hasOnWriteTimeoutHook ||= type === "onWriteTimeout";
+          this._hasBeforeValidateHook ||= type === "beforeValidate";
+          this._hasAfterValidateHook ||= type === "afterValidate";
+          this.hookCache.set(type, fns);
+        }
+      }
+    }
+    this.hooksInitialized = true;
+  }
+  runHooks(name, ...args) {
+    if (!this.hooksInitialized) {
+      this.ensureHooksInitialized();
+    }
+    const fns = this.hookCache.get(name);
+    if (!fns) return;
+    const ctx = args?.[0] instanceof ShokupanContext ? args[0] : void 0;
+    const debug = ctx?.[$debug];
+    if (debug) {
+      return Promise.all(fns.map(async (fn, index) => {
+        const hookId = `hook_${name}_${fn.name || index}`;
+        const previousNode = debug.getCurrentNode();
+        debug.trackEdge(previousNode, hookId);
+        debug.setNode(hookId);
+        const start = performance.now();
+        try {
+          await fn(...args);
+          const duration = performance.now() - start;
+          debug.trackStep(hookId, "hook", duration, "success");
+        } catch (error) {
+          const duration = performance.now() - start;
+          debug.trackStep(hookId, "hook", duration, "error", error);
+          throw error;
+        } finally {
+          if (previousNode) debug.setNode(previousNode);
+        }
+      }));
+    } else {
+      return Promise.all(fns.map((fn) => fn(...args)));
+    }
+  }
+}
+function createHttpServer() {
+  return async (options) => {
+    const server = http$1.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      const request = new Request(url.toString(), {
+        method: req.method,
+        headers: req.headers,
+        body: ["GET", "HEAD"].includes(req.method) ? void 0 : new ReadableStream({
+          start(controller) {
+            req.on("data", (chunk) => controller.enqueue(chunk));
+            req.on("end", () => controller.close());
+            req.on("error", (err) => controller.error(err));
+          }
+        }),
+        // Required for Node.js undici when sending a body
+        duplex: "half"
+      });
+      const response = await options.fetch(request, fauxServer);
+      res.statusCode = response.status;
+      response.headers.forEach((v, k) => res.setHeader(k, v));
+      if (response.body) {
+        const buffer = await response.arrayBuffer();
+        res.end(Buffer.from(buffer));
+      } else {
+        res.end();
+      }
+    });
+    const fauxServer = {
+      stop: () => {
+        server.close();
+        return Promise.resolve();
+      },
+      upgrade(req, options2) {
+        return false;
+      },
+      reload(options2) {
+        return fauxServer;
+      },
+      get port() {
+        const addr = server.address();
+        if (typeof addr === "object" && addr !== null) {
+          return addr.port;
+        }
+        return options.port;
+      },
+      hostname: options.hostname,
+      development: options.development,
+      pendingRequests: 0,
+      requestIP: (req) => null,
+      publish: () => 0,
+      subscriberCount: () => 0,
+      url: new URL(`http://${options.hostname}:${options.port}`),
+      // Expose the raw Node.js server for generic socket/websocket support (e.g. Socket.IO)
+      nodeServer: server
+    };
+    return new Promise((resolve2) => {
+      server.listen(options.port, options.hostname, () => {
+        resolve2(fauxServer);
+      });
+    });
+  };
+}
+class BunAdapter {
+  server;
+  async listen(port, app) {
+    if (typeof Bun === "undefined") {
+      throw new Error("BunAdapter requires the Bun runtime.");
+    }
+    const serveOptions = {
+      port,
+      hostname: app.applicationConfig.hostname,
+      development: app.applicationConfig.development,
+      fetch: app.fetch.bind(app),
+      reusePort: app.applicationConfig.reusePort,
+      idleTimeout: app.applicationConfig.readTimeout ? app.applicationConfig.readTimeout / 1e3 : void 0,
+      websocket: {
+        // @ts-ignore
+        open(ws) {
+          ws.data?.handler?.open?.(ws);
+        },
+        // @ts-ignore
+        async message(ws, message) {
+          if (ws.data?.handler?.message) {
+            return ws.data.handler.message(ws, message);
+          }
+          let msgString = "";
+          if (typeof message === "string") {
+            msgString = message;
+          } else if (message instanceof Uint8Array || message instanceof ArrayBuffer) {
+            msgString = new TextDecoder().decode(message);
+          } else if (typeof Buffer !== "undefined" && message instanceof Buffer) {
+            msgString = message.toString();
+          } else {
+            return;
+          }
+          if (typeof msgString !== "string") return;
+          let payload;
+          let isJSONPayload = false;
+          if (msgString.startsWith("{")) {
+            try {
+              payload = JSON.parse(msgString);
+              isJSONPayload = true;
+            } catch {
+            }
+          }
+          if (payload) {
+            const self = app;
+            if (isJSONPayload && self.applicationConfig["enableHttpBridge"] && payload.type === "HTTP") {
+              const { id, method, path, headers, body } = payload;
+              const url = new URL(path, `http://${self.applicationConfig.hostname || "localhost"}:${port}`);
+              const req = new Request(url.toString(), {
+                method,
+                headers,
+                body: typeof body === "object" ? JSON.stringify(body) : body
+              });
+              const res = await self.fetch(req);
+              const resBody = await res.json().catch((err) => res.text());
+              const resHeaders = {};
+              res.headers.forEach((v, k) => resHeaders[k] = v);
+              ws.send(JSON.stringify({
+                type: "RESPONSE",
+                id,
+                status: res.status,
+                headers: resHeaders,
+                body: resBody
+              }));
+              return;
+            }
+            const eventName = payload.event || (payload.type === "EVENT" ? payload.name : void 0);
+            if (eventName) {
+              const handlers = self.findEvent(eventName);
+              const handler = handlers?.length == 1 ? handlers[0] : compose(handlers || []);
+              if (handler) {
+                const data = payload.data || payload.body || payload.payload || payload;
+                const req = new ShokupanRequest({
+                  url: `http://${self.applicationConfig.hostname || "localhost"}/event/${eventName}`,
+                  method: "POST",
+                  headers: new Headers({ "content-type": "application/json" }),
+                  body: JSON.stringify(data)
+                });
+                const ctx = new ShokupanContext(
+                  // @ts-ignore
+                  req,
+                  // @ts-ignore
+                  self.server,
+                  {},
+                  self,
+                  null,
+                  self.applicationConfig.enableMiddlewareTracking,
+                  payload.id
+                );
+                ctx[$ws] = ws;
+                ws.data ??= {};
+                ws.data["ctx"] = ctx;
+                try {
+                  await handler(ctx);
+                } catch (err) {
+                  if (self.applicationConfig["websocketErrorHandler"]) {
+                    await self.applicationConfig["websocketErrorHandler"](err, ctx);
+                  } else {
+                    console.error(`Error in event ${eventName}:`, err);
+                  }
+                }
+              }
+            }
+          }
+        },
+        // @ts-ignore
+        drain(ws) {
+          ws.data?.handler?.drain?.(ws);
+        },
+        // @ts-ignore
+        close(ws, code, reason) {
+          ws.data?.handler?.close?.(ws, code, reason);
+          const ctx = ws.data?.["ctx"];
+          if (ctx && typeof ctx.getDisconnectCallbacks === "function") {
+            const callbacks = ctx.getDisconnectCallbacks();
+            if (Array.isArray(callbacks) && callbacks.length > 0) {
+              Promise.all(callbacks.map((cb) => cb())).catch((err) => {
+                console.error("Error executing socket disconnect hook:", err);
+              });
+            }
+          }
+        }
+      }
+    };
+    this.server = Bun.serve(serveOptions);
+    return this.server;
   }
-  /**
-   * Attach the verb routes with their overload signatures.
-   * Use compose to handle multiple handlers (middleware).
-   */
-  attachVerb(method, path, ...args) {
-    let spec;
-    let handlers = [];
-    if (args.length > 0) {
-      if (typeof args[0] === "object" && args[0] !== null) {
-        spec = args[0];
-        handlers = args.slice(1);
-      } else {
-        handlers = args;
-      }
-    }
-    if (handlers.length === 0) {
-      return;
-    }
-    let finalHandler = handlers[handlers.length - 1];
-    if (handlers.length > 1) {
-      const fn = compose(handlers);
-      finalHandler = (ctx) => fn(ctx);
+  async stop() {
+    if (this.server) {
+      this.server.stop();
     }
-    this.add({
-      method,
-      path,
-      spec,
-      handler: finalHandler,
-      middleware: handlers.slice(0, handlers.length - 1)
-    });
   }
-  /**
-   * Generates an OpenAPI 3.1 Document by recursing through the router and its descendants.
-   * Now includes runtime analysis of handler functions to infer request/response types.
-   */
-  generateApiSpec(options = {}) {
-    return generateOpenApi(this, options);
+}
+class NodeAdapter {
+  server;
+  async listen(port, app) {
+    let factory = app.applicationConfig.serverFactory;
+    if (!factory) {
+      factory = createHttpServer();
+    }
+    const serveOptions = {
+      port,
+      hostname: app.applicationConfig.hostname,
+      development: app.applicationConfig.development,
+      fetch: app.fetch.bind(app),
+      reusePort: app.applicationConfig.reusePort
+      // Node adapter might not support all options exactly the same
+    };
+    this.server = await factory(serveOptions);
+    return this.server;
   }
-  ensureHooksInitialized() {
-    const hooks = this.config?.hooks;
-    if (hooks) {
-      const hookList = Array.isArray(hooks) ? hooks : [hooks];
-      const hookTypes = [
-        "onRequestStart",
-        "onRequestEnd",
-        "onResponseStart",
-        "onResponseEnd",
-        "onError",
-        "beforeValidate",
-        "afterValidate",
-        "onRequestTimeout",
-        "onReadTimeout",
-        "onWriteTimeout"
-      ];
-      for (let i = 0; i < hookTypes.length; i++) {
-        const type = hookTypes[i];
-        const fns = [];
-        for (let j = 0; j < hookList.length; j++) {
-          const h = hookList[j];
-          if (h[type]) fns.push(h[type]);
-        }
-        if (fns.length > 0) {
-          this.hookCache.set(type, fns);
-        }
-      }
+  async stop() {
+    if (this.server?.stop) {
+      await this.server.stop();
     }
-    this.hooksInitialized = true;
   }
-  runHooks(name, ...args) {
-    if (!this.hooksInitialized) {
-      this.ensureHooksInitialized();
+}
+let fs;
+class DefaultFileSystemAdapter {
+  async readFile(path) {
+    if (typeof Bun !== "undefined") {
+      return Bun.file(path);
+    } else {
+      fs ??= await import("node:fs/promises");
+      return fs.readFile(path);
     }
-    const fns = this.hookCache.get(name);
-    if (!fns) return;
-    const ctx = args?.[0] instanceof ShokupanContext ? args[0] : void 0;
-    const debug = ctx?.[$debug];
-    if (debug) {
-      return Promise.all(fns.map(async (fn, index) => {
-        const hookId = `hook_${name}_${fn.name || index}`;
-        const previousNode = debug.getCurrentNode();
-        debug.trackEdge(previousNode, hookId);
-        debug.setNode(hookId);
-        const start = performance.now();
-        try {
-          await fn(...args);
-          const duration = performance.now() - start;
-          debug.trackStep(hookId, "hook", duration, "success");
-        } catch (error) {
-          const duration = performance.now() - start;
-          debug.trackStep(hookId, "hook", duration, "error", error);
-          throw error;
-        } finally {
-          if (previousNode) debug.setNode(previousNode);
-        }
-      }));
+  }
+  async stat(path) {
+    if (typeof Bun !== "undefined") {
+      const file = Bun.file(path);
+      return {
+        size: file.size,
+        mtime: new Date(file.lastModified)
+      };
     } else {
-      return Promise.all(fns.map((fn) => fn(...args)));
+      fs ??= await import("node:fs/promises");
+      const stats = await fs.stat(path);
+      return {
+        size: stats.size,
+        mtime: stats.mtime
+      };
     }
   }
 }
@@ -2724,13 +3259,24 @@ const asyncContext = new AsyncLocalStorage();
 class SystemCpuMonitor {
   constructor(intervalMs = 1e3) {
     this.intervalMs = intervalMs;
+    this.init();
   }
   interval = null;
   lastCpus = [];
   currentUsage = 0;
+  osStub = null;
+  async init() {
+    try {
+      if (typeof process !== "undefined" && process.versions && process.versions.node) {
+        this.osStub = await import("node:os");
+      }
+    } catch (e) {
+    }
+  }
   start() {
     if (this.interval) return;
-    this.lastCpus = os.cpus();
+    if (!this.osStub) return;
+    this.lastCpus = this.osStub.cpus();
     this.interval = setInterval(() => this.update(), this.intervalMs);
   }
   stop() {
@@ -2743,12 +3289,14 @@ class SystemCpuMonitor {
     return this.currentUsage;
   }
   update() {
-    const cpus = os.cpus();
+    if (!this.osStub) return;
+    const cpus = this.osStub.cpus();
     let idle = 0;
     let total = 0;
     for (let i = 0; i < cpus.length; i++) {
       const cpu = cpus[i];
       const prev = this.lastCpus[i];
+      if (!prev) continue;
       let type;
       for (type in cpu.times) {
         const ticks = cpu.times[type];
@@ -2866,11 +3414,12 @@ const defaults = {
   enableHttpBridge: false,
   reusePort: false
 };
-trace.getTracer("shokupan.application");
 class Shokupan extends ShokupanRouter {
   applicationConfig = {};
   openApiSpec;
   asyncApiSpec;
+  openApiSpecPromise;
+  asyncApiSpecPromise;
   composedMiddleware;
   cpuMonitor;
   server;
@@ -2884,6 +3433,7 @@ class Shokupan extends ShokupanRouter {
   }
   constructor(applicationConfig = {}) {
     const config = Object.assign({}, defaults, applicationConfig);
+    config.fileSystem ??= new DefaultFileSystemAdapter();
     const { hooks, ...routerConfig } = config;
     super({ ...routerConfig, hooks });
     this[$isApplication] = true;
@@ -2895,61 +3445,51 @@ class Shokupan extends ShokupanRouter {
       line,
       name: "ShokupanApplication"
     };
-    this.dbPromise = this.initDatastore();
+    if (this.applicationConfig.adapter !== "wintercg") {
+      this.dbPromise = this.initDatastore().catch((err) => {
+        this.logger?.debug("Failed to initialize default datastore", { error: err });
+      });
+    }
   }
   async initDatastore() {
-    const db = new Surreal({ engines: this.applicationConfig.surreal?.engines ?? (await import("@surrealdb/node")).createNodeEngines() });
+    let engines = this.applicationConfig.surreal?.engines;
+    if (!engines && !this.applicationConfig.surreal?.url?.match(/^(?:wss?|https?):\/\//)) {
+      engines = (await import("@surrealdb/node")).createNodeEngines();
+    }
+    const db = new Surreal({ engines });
     this.datastore = new SurrealDatastore(db);
     await db.connect(
       this.applicationConfig.surreal?.url ?? (process.env.NODE_ENV === "test" ? "mem://" : "surrealkv://database"),
       this.applicationConfig.surreal?.connectOptions
-    );
+    ).catch((err) => {
+      this.logger?.error("Failed to connect to SurrealDB", { error: err });
+    });
     await db.use({
       namespace: this.applicationConfig.surreal?.namespace ?? "vendor",
       database: this.applicationConfig.surreal?.database ?? "shokupan"
     });
+    await db.query("DEFINE TABLE OVERWRITE request;");
+    await db.query("DEFINE TABLE OVERWRITE failed_request;");
+    await db.query("DEFINE TABLE OVERWRITE metric;");
   }
+  /**
+   * Adds middleware to the application.
+   */
   /**
    * Adds middleware to the application.
    */
   use(middleware) {
     const { file, line } = getCallerInfo();
-    if (!middleware.metadata) {
-      middleware.metadata = {
-        file,
-        line,
-        name: middleware.name || "middleware",
-        isBuiltin: middleware.isBuiltin,
-        pluginName: middleware.pluginName
-      };
-    }
+    const wrapped = MiddlewareTracker.wrap(middleware, {
+      file,
+      line,
+      name: middleware.name || "middleware",
+      isBuiltin: middleware.isBuiltin,
+      pluginName: middleware.pluginName
+    });
     if (this.applicationConfig.enableMiddlewareTracking) {
-      const trackedMiddleware = async (ctx, next) => {
-        const c = ctx;
-        if (c.handlerStack && c.app?.applicationConfig.enableMiddlewareTracking) {
-          const metadata = middleware.metadata || {};
-          const start = performance.now();
-          const item = {
-            name: metadata.pluginName ? `${metadata.pluginName} (${metadata.name})` : metadata.name || middleware.name || "middleware",
-            file: metadata.file || file,
-            line: metadata.line || line,
-            isBuiltin: metadata.isBuiltin,
-            startTime: start,
-            duration: -1
-          };
-          c.handlerStack.push(item);
-          try {
-            return await middleware(ctx, next);
-          } finally {
-            item.duration = performance.now() - start;
-          }
-        }
-        return middleware(ctx, next);
-      };
-      trackedMiddleware.metadata = middleware.metadata;
-      Object.defineProperty(trackedMiddleware, "name", { value: middleware.name || "middleware" });
-      trackedMiddleware.order = this.middleware.length;
-      this.middleware.push(trackedMiddleware);
+      wrapped.order = this.middleware.length;
+      this.middleware.push(wrapped);
     } else {
       this.middleware.push(middleware);
     }
@@ -2992,18 +3532,19 @@ class Shokupan extends ShokupanRouter {
     }
     await Promise.all(this.startupHooks.map((hook) => hook()));
     if (this.applicationConfig.enableOpenApiGen) {
-      this.openApiSpec = await generateOpenApi(this);
-      this.get("/.well-known/openapi.yaml", (ctx) => {
+      this.get("/.well-known/openapi.yaml", async (ctx) => {
         try {
+          await this.openApiSpecPromise;
           const yaml = dump(this.openApiSpec);
           return ctx.send(yaml, { status: 200, headers: { "content-type": "application/yaml" } });
         } catch (e) {
-          this.logger.error("Failed to generate OpenAPI YAML", { error: e });
+          this.logger?.error("Failed to generate OpenAPI YAML", { error: e });
           return ctx.text("Internal Server Error", 500);
         }
       });
       if (this.applicationConfig.aiPlugin?.enabled !== false) {
         this.get("/.well-known/ai-plugin.json", async (ctx) => {
+          await this.openApiSpecPromise;
           const config = this.applicationConfig.aiPlugin || {};
           let pkg = {};
           try {
@@ -3031,7 +3572,8 @@ class Shokupan extends ShokupanRouter {
         });
       }
       if (this.applicationConfig.apiCatalog?.enabled !== false) {
-        this.get("/.well-known/api-catalog", (ctx) => {
+        this.get("/.well-known/api-catalog", async (ctx) => {
+          await this.openApiSpecPromise;
           const config = this.applicationConfig.apiCatalog || {};
           const catalog = {
             versions: config.versions || [
@@ -3045,110 +3587,57 @@ class Shokupan extends ShokupanRouter {
           return ctx.json(catalog);
         });
       }
-      await Promise.all(this.specAvailableHooks.map((hook) => hook(this.openApiSpec)));
+      this.openApiSpecPromise = generateOpenApi(this).then((spec) => {
+        this.openApiSpec = spec;
+        return spec;
+      });
+      const shouldBlock = this.applicationConfig.blockOnOpenApiGen !== false;
+      if (shouldBlock) {
+        await this.openApiSpecPromise;
+      }
+      if (shouldBlock) {
+        await Promise.all(this.specAvailableHooks.map((hook) => hook(this.openApiSpec)));
+      } else {
+        this.openApiSpecPromise.then((spec) => {
+          return Promise.all(this.specAvailableHooks.map((hook) => hook(spec)));
+        }).catch((err) => {
+          this.logger?.error("Error running spec available hooks", { error: err });
+        });
+      }
     }
     if (this.applicationConfig.enableAsyncApiGen) {
       const { generateAsyncApi: generateAsyncApi2 } = await Promise.resolve().then(() => generator);
-      this.asyncApiSpec = await generateAsyncApi2(this);
+      this.asyncApiSpecPromise = generateAsyncApi2(this).then((spec) => {
+        this.asyncApiSpec = spec;
+        return spec;
+      });
+      const shouldBlock = this.applicationConfig.blockOnAsyncApiGen !== false;
+      if (shouldBlock) {
+        await this.asyncApiSpecPromise;
+      }
     }
     if (port === 0 && process.platform === "linux") ;
     if (this.applicationConfig.autoBackpressureFeedback === true) {
       this.cpuMonitor = new SystemCpuMonitor();
       this.cpuMonitor.start();
     }
-    const self = this;
-    const serveOptions = {
-      port: finalPort,
-      hostname: this.applicationConfig.hostname,
-      development: this.applicationConfig.development,
-      fetch: this.fetch.bind(this),
-      reusePort: this.applicationConfig.reusePort,
-      idleTimeout: this.applicationConfig.readTimeout ? this.applicationConfig.readTimeout / 1e3 : void 0,
-      websocket: {
-        open(ws) {
-          ws.data?.handler?.open?.(ws);
-        },
-        async message(ws, message) {
-          if (ws.data?.handler?.message) {
-            return ws.data.handler.message(ws, message);
-          }
-          if (typeof message !== "string") return;
-          try {
-            const payload = JSON.parse(message);
-            if (self.applicationConfig["enableHttpBridge"] && payload.type === "HTTP") {
-              const { id, method, path, headers, body } = payload;
-              const url = new URL(path, `http://${self.applicationConfig.hostname || "localhost"}:${finalPort}`);
-              const req = new Request(url.toString(), {
-                method,
-                headers,
-                body: typeof body === "object" ? JSON.stringify(body) : body
-              });
-              const res = await self.fetch(req);
-              const resBody = await res.json().catch((err) => res.text());
-              const resHeaders = {};
-              res.headers.forEach((v, k) => resHeaders[k] = v);
-              ws.send(JSON.stringify({
-                type: "RESPONSE",
-                id,
-                status: res.status,
-                headers: resHeaders,
-                body: resBody
-              }));
-              return;
-            }
-            const eventName = payload.event || (payload.type === "EVENT" ? payload.name : void 0);
-            if (eventName) {
-              const handlers = self.findEvent(eventName);
-              const handler = handlers?.length == 1 ? handlers[0] : compose(handlers);
-              if (handler) {
-                const data = payload.data || payload.payload;
-                const req = new ShokupanRequest({
-                  url: `http://${self.applicationConfig.hostname || "localhost"}/event/${eventName}`,
-                  method: "POST",
-                  headers: new Headers({ "content-type": "application/json" }),
-                  body: JSON.stringify(data)
-                });
-                const ctx = new ShokupanContext(req, self.server);
-                ctx[$ws] = ws;
-                ws.data ??= {};
-                ws.data["ctx"] = ctx;
-                try {
-                  await handler(ctx);
-                } catch (err) {
-                  if (self.applicationConfig["websocketErrorHandler"]) {
-                    await self.applicationConfig["websocketErrorHandler"](err, ctx);
-                  } else {
-                    console.error(`Error in event ${eventName}:`, err);
-                  }
-                }
-              }
-            }
-          } catch (e) {
-          }
-        },
-        drain(ws) {
-          ws.data?.handler?.drain?.(ws);
-        },
-        close(ws, code, reason) {
-          ws.data?.handler?.close?.(ws, code, reason);
-          const ctx = ws.data?.["ctx"];
-          if (ctx && typeof ctx.getDisconnectCallbacks === "function") {
-            const callbacks = ctx.getDisconnectCallbacks();
-            if (Array.isArray(callbacks) && callbacks.length > 0) {
-              Promise.all(callbacks.map((cb) => cb())).catch((err) => {
-                console.error("Error executing socket disconnect hook:", err);
-              });
-            }
-          }
-        }
+    let adapter = this.applicationConfig.adapter;
+    if (!adapter) {
+      if (typeof Bun !== "undefined") {
+        this.applicationConfig.adapter = "bun";
+        adapter = new BunAdapter();
+      } else {
+        this.applicationConfig.adapter = "node";
+        adapter = new NodeAdapter();
       }
-    };
-    let factory = this.applicationConfig.serverFactory;
-    if (!factory && typeof Bun === "undefined") {
-      const { createHttpServer } = await import("./http-server-CCeagTyU.js");
-      factory = createHttpServer();
+    } else if (adapter === "bun") {
+      adapter = new BunAdapter();
+    } else if (adapter === "node") {
+      adapter = new NodeAdapter();
+    } else if (adapter === "wintercg") {
+      throw new Error("WinterCG adapter does not support listen(). Use fetch directly.");
     }
-    this.server = factory ? await factory(serveOptions) : Bun.serve(serveOptions);
+    this.server = await adapter.listen(finalPort, this);
     return this.server;
   }
   /**
@@ -3201,11 +3690,16 @@ class Shokupan extends ShokupanRouter {
       }
       url = u.toString();
     }
+    const reqBody = options.body && typeof options.body === "object" ? JSON.stringify(options.body) : options.body;
+    const reqHeaders = new Headers(options.headers);
+    if (typeof options.body === "object" && !reqHeaders.has("content-type")) {
+      reqHeaders.set("content-type", "application/json");
+    }
     const req = new ShokupanRequest({
       method: options.method || "GET",
       url,
-      headers: options.headers,
-      body: options.body && typeof options.body === "object" ? JSON.stringify(options.body) : options.body
+      headers: reqHeaders,
+      body: reqBody
     });
     const res = await this.fetch(req);
     const status = res.status;
@@ -3265,19 +3759,22 @@ class Shokupan extends ShokupanRouter {
       if (this.cpuMonitor && this.cpuMonitor.getUsage() > (this.applicationConfig.autoBackpressureLevel ?? 60)) {
         const msg = "Too Many Requests (CPU Backpressure)";
         const res = ctx.text(msg, 429);
-        await this.runHooks("onResponseEnd", ctx, res);
+        if (this.hasOnResponseEndHook) await this.runHooks("onResponseEnd", ctx, res);
         return res;
       }
       try {
-        await this.runHooks("onRequestStart", ctx);
+        if (this.hasOnRequestStartHook) await this.runHooks("onRequestStart", ctx);
         const fn = this.composedMiddleware ??= compose(this.middleware);
         const result = await fn(ctx, async () => {
-          const bodyParsing = ["POST", "PUT", "PATCH", "DELETE"].includes(req.method) ? ctx.parseBody() : Promise.resolve();
+          let bodyParsing;
+          if (req.method !== "GET" && req.method !== "HEAD") {
+            bodyParsing = ctx.parseBody();
+          }
           const match = this.find(req.method, ctx.path);
           if (match) {
             ctx[$routeMatched] = true;
             ctx.params = match.params;
-            await bodyParsing;
+            if (bodyParsing) await bodyParsing;
             return match.handler(ctx);
           }
           return null;
@@ -3309,19 +3806,22 @@ class Shokupan extends ShokupanRouter {
         } else {
           response = ctx.text(String(result));
         }
-        await this.runHooks("onRequestEnd", ctx);
+        if (this.hasOnRequestEndHook) await this.runHooks("onRequestEnd", ctx);
         if (response instanceof Promise) {
           response = await response;
         }
-        await this.runHooks("onResponseStart", ctx, response);
+        if (this.hasOnResponseStartHook) await this.runHooks("onResponseStart", ctx, response);
         return response;
       } catch (err) {
         const span = asyncContext.getStore()?.span;
         if (span) span.setStatus({ code: 2 });
-        const status = getErrorStatus(err);
+        let status = getErrorStatus(err);
+        if (err instanceof SyntaxError && err.message.includes("JSON")) {
+          status = 400;
+        }
         const body = { error: err.message || "Internal Server Error" };
         if (err.errors) body.errors = err.errors;
-        await this.runHooks("onError", ctx, err);
+        if (this.hasOnErrorHook) await this.runHooks("onError", ctx, err);
         return ctx.json(body, status);
       }
     };
@@ -3658,16 +4158,48 @@ function ApiExplorerApp({ spec, asyncSpec, config }) {
     const commonPrefix = findCommonPrefix(routes);
     const commonPrefixPath = "/" + commonPrefix.join("/");
     const children = createSubgroups(routes, 0, commonPrefix.length);
+    const groupMiddleware = [];
+    if (spec["x-middleware-registry"]) {
+      Object.entries(spec["x-middleware-registry"]).forEach(([id, mw]) => {
+        const firstRoute = routes[0];
+        const routeSource = firstRoute?.op?.["x-shokupan-source"];
+        const mwFile = mw.file?.split("/").pop();
+        const routeFile = routeSource?.file?.split("/").pop();
+        if (mwFile && routeFile && mwFile === routeFile && mw.scope !== "global") {
+          groupMiddleware.push({ ...mw, id, type: "middleware" });
+        }
+      });
+    }
+    const isBuiltin = routes.some((r) => r.op["x-shokupan-builtin"] === true);
     return {
       name,
       type: "group",
       children,
-      commonPrefixPath
+      middleware: groupMiddleware,
+      commonPrefixPath,
       // Store for display stripping
+      isBuiltin
     };
-  }).sort((a, b) => {
+  });
+  if (spec["x-middleware-registry"]) {
+    const allGroupMiddleware = hierarchicalGroups.flatMap((g) => g.middleware || []).map((m) => m.id);
+    const globalMiddleware = Object.entries(spec["x-middleware-registry"]).filter(([id]) => !allGroupMiddleware.includes(id)).map(([id, mw]) => ({ ...mw, id, type: "middleware" }));
+    if (globalMiddleware.length > 0) {
+      hierarchicalGroups.push({
+        name: "Global Middleware",
+        type: "group",
+        children: [],
+        middleware: globalMiddleware,
+        commonPrefixPath: "",
+        isBuiltin: false
+      });
+    }
+  }
+  hierarchicalGroups.sort((a, b) => {
     if (a.name === "Ungrouped") return 1;
     if (b.name === "Ungrouped") return -1;
+    if (a.name === "Global Middleware") return 1;
+    if (b.name === "Global Middleware") return -1;
     return a.name.localeCompare(b.name);
   });
   const allRoutes = Array.from(hierarchy.values()).flat();
@@ -3676,6 +4208,9 @@ function ApiExplorerApp({ spec, asyncSpec, config }) {
       /* @__PURE__ */ jsx("meta", { charSet: "UTF-8" }),
       /* @__PURE__ */ jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" }),
       /* @__PURE__ */ jsx("title", { children: spec.info?.title || "API Explorer" }),
+      /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.googleapis.com" }),
+      /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.gstatic.com", crossorigin: "anonymous" }),
+      /* @__PURE__ */ jsx("link", { href: "https://fonts.googleapis.com/css2?family=Google+Sans+Code:ital,wght@0,300..800;1,300..800&family=Vend+Sans:ital,wght@0,300..700;1,300..700&display=swap", rel: "stylesheet" }),
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: "style.css" }),
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: "theme.css" }),
       /* @__PURE__ */ jsx("script", { src: "https://cdn.jsdelivr.net/npm/marked@4.3.0/marked.min.js" }),
@@ -3772,13 +4307,46 @@ function Sidebar$1({ spec, hierarchicalGroups }) {
       /* @__PURE__ */ jsx("div", { class: "version", children: spec.info?.version })
     ] }),
     /* @__PURE__ */ jsx("div", { class: "sidebar-collapse-trigger", children: "➔" }),
-    /* @__PURE__ */ jsx("nav", { class: "nav-groups", children: hierarchicalGroups.map((group) => /* @__PURE__ */ jsxs("div", { class: "nav-group collapsed", children: [
+    /* @__PURE__ */ jsx("nav", { class: "nav-groups", children: hierarchicalGroups.map((group) => /* @__PURE__ */ jsxs("div", { class: `nav-group collapsed ${group.isBuiltin ? "builtin-group" : ""}`, children: [
       /* @__PURE__ */ jsxs("div", { class: "nav-group-title", children: [
         /* @__PURE__ */ jsx("span", { class: "chevron", children: /* @__PURE__ */ jsx("svg", { width: "12", height: "12", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", children: /* @__PURE__ */ jsx("polyline", { points: "9 18 15 12 9 6" }) }) }),
-        " ",
+        group.isBuiltin && /* @__PURE__ */ jsx("span", { class: "builtin-icon", title: "Built-in Plugin", children: /* @__PURE__ */ jsxs("svg", { width: "12", height: "12", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", children: [
+          /* @__PURE__ */ jsx("rect", { x: "2", y: "2", width: "20", height: "20", rx: "5", ry: "5" }),
+          /* @__PURE__ */ jsx("path", { d: "M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z" }),
+          /* @__PURE__ */ jsx("line", { x1: "17.5", y1: "6.5", x2: "17.51", y2: "6.5" })
+        ] }) }),
         group.name
       ] }),
-      /* @__PURE__ */ jsx("div", { class: "nav-items", children: group.children?.map((child) => renderNavNode(child, 0, group.commonPrefixPath || "")) })
+      /* @__PURE__ */ jsxs("div", { class: "nav-items", children: [
+        group.middleware && group.middleware.length > 0 && /* @__PURE__ */ jsx("div", { class: "group-middleware", children: group.middleware.map((mw) => /* @__PURE__ */ jsxs(
+          "a",
+          {
+            href: `#middleware-${mw.id}`,
+            class: "nav-item middleware-nav-item",
+            "data-middleware-id": mw.id,
+            title: mw.name,
+            children: [
+              /* @__PURE__ */ jsx("span", { class: "middleware-icon", children: "⚙" }),
+              /* @__PURE__ */ jsx("span", { class: "nav-label", children: mw.name }),
+              mw.usedBy && mw.usedBy.length > 0 && /* @__PURE__ */ jsx("span", { class: "middleware-badge", title: `Used by ${mw.usedBy.length} routes`, children: mw.usedBy.length }),
+              mw.file && /* @__PURE__ */ jsx(
+                "a",
+                {
+                  href: `vscode://file/${mw.file}:${mw.startLine || 1}`,
+                  class: "nav-source-link",
+                  title: `${mw.file}:${mw.startLine || 1}`,
+                  children: /* @__PURE__ */ jsxs("svg", { width: "10", height: "10", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", children: [
+                    /* @__PURE__ */ jsx("polyline", { points: "16 18 22 12 16 6" }),
+                    /* @__PURE__ */ jsx("polyline", { points: "8 6 2 12 8 18" })
+                  ] })
+                }
+              )
+            ]
+          },
+          mw.id
+        )) }),
+        group.children?.map((child) => renderNavNode(child, 0, group.commonPrefixPath || ""))
+      ] })
     ] }, group.name)) })
   ] });
 }
@@ -3786,7 +4354,8 @@ function MainContent$1({ allRoutes, config, spec }) {
   const explorerData = JSON.stringify({
     routes: allRoutes,
     config,
-    info: spec.info
+    info: spec.info,
+    middlewareRegistry: spec["x-middleware-registry"] || {}
   });
   const safeJson = explorerData.replace(/<\/script>/g, "<\\/script>");
   return /* @__PURE__ */ jsxs("main", { class: "content", id: "main-content", children: [
@@ -3796,9 +4365,16 @@ function MainContent$1({ allRoutes, config, spec }) {
 }
 class ApiExplorerPlugin extends ShokupanRouter {
   constructor(pluginOptions = {}) {
+    console.log("ApiExplorerPlugin: CONSTRUCTOR CALLED");
     super({ renderer: renderToString });
     this.pluginOptions = pluginOptions;
     pluginOptions.path ??= "/explorer";
+    this.metadata = {
+      file: import.meta.file,
+      line: 1,
+      name: "ApiExplorerPlugin",
+      pluginName: "ApiExplorer"
+    };
     this.init();
   }
   onInit(app, options) {
@@ -3829,6 +4405,7 @@ class ApiExplorerPlugin extends ShokupanRouter {
             delete op["x-source-info"].snippet;
           }
           if (op["x-shokupan-source"]?.code) {
+            console.log("Deleting x-shokupan-source.code");
             delete op["x-shokupan-source"].code;
           }
         });
@@ -3855,7 +4432,10 @@ class ApiExplorerPlugin extends ShokupanRouter {
     this.get("/", async (ctx) => {
       const spec = this.root.openApiSpec ? structuredClone(this.root.openApiSpec) : await (this.root || this).generateApiSpec();
       const asyncSpec = ctx.app.asyncApiSpec;
-      return ctx.jsx(ApiExplorerApp({ spec: stripSourceCode(spec), asyncSpec }));
+      const element = ApiExplorerApp({ spec: stripSourceCode(spec), asyncSpec });
+      const html = renderToString(element);
+      if (html.length === 0) throw new Error("ApiExplorerPlugin: rendered page is blank.");
+      return ctx.html(html);
     });
   }
 }
@@ -3866,8 +4446,8 @@ function AsyncApiApp({ spec, serverUrl, base, disableSourceView, navTree }) {
       /* @__PURE__ */ jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" }),
       /* @__PURE__ */ jsx("title", { children: "Shokupan AsyncAPI" }),
       /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.googleapis.com" }),
-      /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.gstatic.com", crossOrigin: "anonymous" }),
-      /* @__PURE__ */ jsx("link", { href: "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap", rel: "stylesheet" }),
+      /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.gstatic.com", crossorigin: "anonymous" }),
+      /* @__PURE__ */ jsx("link", { href: "https://fonts.googleapis.com/css2?family=Google+Sans+Code:ital,wght@0,300..800;1,300..800&family=Vend+Sans:ital,wght@0,300..700;1,300..700&display=swap", rel: "stylesheet" }),
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/theme.css` }),
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/style.css` }),
       /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: {
@@ -3875,6 +4455,7 @@ function AsyncApiApp({ spec, serverUrl, base, disableSourceView, navTree }) {
                     window.INITIAL_SPEC = ${JSON.stringify(spec)};
                     window.INITIAL_SERVER_URL = "${serverUrl}";
                     window.DISABLE_SOURCE_VIEW = ${JSON.stringify(disableSourceView)};
+                    window.BASE_PATH = "${base}";
                 `
       } })
     ] }),
@@ -3945,8 +4526,14 @@ function LeafNode({ item, label, disableSourceView }) {
     ] });
   } else {
     const badgeText = item.data.type === "publish" ? "SEND" : "RECV";
+    const isPlugin = item.data.op?.["x-shokupan-plugin-name"] || sourceInfo?.pluginName;
     content = /* @__PURE__ */ jsxs(Fragment, { children: [
       /* @__PURE__ */ jsx("span", { class: `badge badge-${badgeText}`, children: badgeText }),
+      isPlugin && /* @__PURE__ */ jsx("span", { class: "builtin-icon", title: "Built-in Plugin", children: /* @__PURE__ */ jsxs("svg", { width: "12", height: "12", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", children: [
+        /* @__PURE__ */ jsx("rect", { x: "2", y: "2", width: "20", height: "20", rx: "5", ry: "5" }),
+        /* @__PURE__ */ jsx("path", { d: "M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z" }),
+        /* @__PURE__ */ jsx("line", { x1: "17.5", y1: "6.5", x2: "17.51", y2: "6.5" })
+      ] }) }),
       /* @__PURE__ */ jsx("span", { class: "tree-label", children: label })
     ] });
   }
@@ -4043,45 +4630,56 @@ function buildNavTree(spec) {
   });
   return root;
 }
-async function getAstRoutes(applications) {
-  const astRoutes = [];
-  const getExpandedRoutes = (app, prefix = "", seen = /* @__PURE__ */ new Set()) => {
-    if (seen.has(app.name)) return [];
-    const newSeen = new Set(seen);
-    newSeen.add(app.name);
-    const expanded = [];
-    for (const route of app.routes) {
-      expanded.push({
-        ...route,
-        // For events, path is the event name
-        path: route.path.startsWith("/") ? route.path.slice(1) : route.path
-      });
-    }
-    if (app.mounted) {
-      for (const mount of app.mounted) {
-        const targetApp = applications.find((a) => a.name === mount.target || a.className === mount.target);
-        if (targetApp) {
-          expanded.push(...getExpandedRoutes(targetApp, "", newSeen));
-        }
-      }
-    }
-    return expanded;
-  };
-  applications.forEach((app) => {
-    astRoutes.push(...getExpandedRoutes(app));
-  });
-  return astRoutes;
+function hasUnknownFields(schema) {
+  if (!schema) return false;
+  if (schema["x-unknown"]) return true;
+  if (schema.type === "object" && schema.properties) {
+    return Object.values(schema.properties).some(
+      (prop) => hasUnknownFields(prop)
+    );
+  }
+  if (schema.type === "array" && schema.items) {
+    return hasUnknownFields(schema.items);
+  }
+  return false;
 }
 async function generateAsyncApi(rootRouter, options = {}) {
   const channels = {};
   let astRoutes = [];
+  let astMiddlewareRegistry = {};
+  let applications = [];
   try {
-    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-BqIe1p0R.js");
+    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-CnKnQ5KV.js");
     const entrypoint = globalThis.Bun?.main || require.main?.filename || process.argv[1];
     const analyzer = new OpenAPIAnalyzer2(process.cwd(), entrypoint);
-    const { applications } = await analyzer.analyze();
-    astRoutes = await getAstRoutes(applications);
+    const analysisResult = await analyzer.analyze();
+    applications = analysisResult.applications;
+    astRoutes = await getAstRoutes(applications, {
+      includePrefix: false,
+      pathTransform: (p) => p.startsWith("/") ? p.slice(1) : p
+    });
+    let middlewareId = 0;
+    for (const app of applications) {
+      if (app.middleware && app.middleware.length > 0) {
+        for (const mw of app.middleware) {
+          const id = `middleware-${middlewareId++}`;
+          astMiddlewareRegistry[id] = {
+            ...mw,
+            id,
+            usedBy: []
+            // Will be populated when processing events
+          };
+        }
+      }
+    }
   } catch (e) {
+    if (options.warnings) {
+      options.warnings.push({
+        type: "ast-analysis-failed",
+        message: "AST Analysis failed or skipped",
+        detail: e.message
+      });
+    }
   }
   const matchedAstRoutes = /* @__PURE__ */ new Set();
   const collect = async (router, prefix = "") => {
@@ -4125,23 +4723,45 @@ async function generateAsyncApi(rootRouter, options = {}) {
             endLine: astMatch?.sourceContext?.endLine,
             highlightLines: astMatch?.sourceContext ? [astMatch.sourceContext.startLine, astMatch.sourceContext.endLine] : void 0
           } : void 0;
+          const message = {
+            ...userSpec?.message || {}
+          };
+          let inferenceFailed = false;
+          if (!message.payload) {
+            if (astMatch) {
+              if (astMatch.requestTypes?.body) {
+                message.payload = astMatch.requestTypes.body;
+                if (message.payload.type === "object" && !message.payload.properties && !message.payload.additionalProperties && Object.keys(message.payload).length === 1) {
+                  inferenceFailed = true;
+                }
+              }
+            } else {
+              message.payload = { type: "object" };
+              inferenceFailed = true;
+            }
+          }
           if (!channels[eventName]) {
-            channels[eventName] = {
-              publish: {
-                operationId: `on${eventName.charAt(0).toUpperCase() + eventName.slice(1)}`,
-                tags,
-                message: {
-                  payload: { type: "object" },
-                  ...userSpec?.message ? userSpec.message : {}
-                },
-                ...userSpec?.type === "publish" ? userSpec : {},
-                "x-source-info": sourceInfo ? [sourceInfo] : [],
-                "x-shokupan-source": sourceInfo
-                // Simplified
+            const publishOp = {
+              operationId: `on${eventName.charAt(0).toUpperCase() + eventName.slice(1)}`,
+              tags,
+              message,
+              ...userSpec?.type === "publish" ? userSpec : {},
+              "x-source-info": sourceInfo ? [sourceInfo] : [],
+              "x-shokupan-source": {
+                ...sourceInfo,
+                pluginName: handler.pluginName
               }
             };
-            if (userSpec?.summary) channels[eventName].publish.summary = userSpec.summary;
-            if (userSpec?.description) channels[eventName].publish.description = userSpec.description;
+            if (inferenceFailed) {
+              publishOp["x-warning"] = true;
+              if (!publishOp.summary) publishOp.summary = "Payload Inference Failed";
+              if (!publishOp.description) publishOp.description = "The payload format could not be statically inferred from the source code. Please add a type assertion or @Spec decorator.";
+            }
+            if (userSpec?.summary && !publishOp.summary) publishOp.summary = userSpec.summary;
+            if (userSpec?.description && !publishOp.description) publishOp.description = userSpec.description;
+            channels[eventName] = {
+              publish: publishOp
+            };
           } else {
             if (sourceInfo) {
               if (!channels[eventName].publish["x-source-info"]) {
@@ -4159,6 +4779,14 @@ async function generateAsyncApi(rootRouter, options = {}) {
           for (const emit of emits) {
             if (emit.event === "__DYNAMIC_EMIT__") {
               const warningKey = `${eventName}/Dynamic Emit`;
+              if (options.warnings) {
+                options.warnings.push({
+                  type: "dynamic-emit",
+                  message: "Dynamic emit detected",
+                  detail: `Event: ${eventName}`,
+                  location: { file: astMatch?.sourceContext?.file, line: emit.location?.startLine }
+                });
+              }
               channels[warningKey] = {
                 subscribe: {
                   operationId: `dynamicEmitWarning${eventName}`,
@@ -4193,17 +4821,24 @@ async function generateAsyncApi(rootRouter, options = {}) {
               emitHighlightLines: [emitStart, emitEnd]
             } : void 0;
             if (!channels[emit.event]) {
+              const payload = emit.payload || { type: "object" };
+              const warning = hasUnknownFields(payload);
               channels[emit.event] = {
                 subscribe: {
                   operationId: `emit${emit.event.charAt(0).toUpperCase() + emit.event.slice(1)}`,
                   tags,
                   message: {
-                    payload: emit.payload || { type: "object" }
+                    payload
                   },
+                  ...warning ? {
+                    "x-warning": true,
+                    "x-warning-reason": "Payload contains fields with unknown types that could not be statically analyzed"
+                  } : {},
                   "x-source-info": newSourceInfo ? [newSourceInfo] : [],
                   "x-shokupan-source": sourceInfo && emitStart ? {
                     file: sourceInfo.file,
-                    line: emitStart
+                    line: emitStart,
+                    pluginName: handler.pluginName
                   } : void 0
                 }
               };
@@ -4267,13 +4902,19 @@ async function generateAsyncApi(rootRouter, options = {}) {
             emitHighlightLines: [emitStart, emitEnd]
           } : void 0;
           if (!channels[emit.event]) {
+            const payload = emit.payload || { type: "object" };
+            const warning = hasUnknownFields(payload);
             channels[emit.event] = {
               subscribe: {
                 operationId: `emit${emit.event.charAt(0).toUpperCase() + emit.event.slice(1)}`,
                 tags,
                 message: {
-                  payload: emit.payload || { type: "object" }
+                  payload
                 },
+                ...warning ? {
+                  "x-warning": true,
+                  "x-warning-reason": "Payload contains fields with unknown types that could not be statically analyzed"
+                } : {},
                 "x-source-info": newSourceInfo ? [newSourceInfo] : [],
                 "x-shokupan-source": sourceInfo && emitStart ? {
                   file: sourceInfo.file,
@@ -4312,6 +4953,14 @@ async function generateAsyncApi(rootRouter, options = {}) {
       if (parts.length > 0) prefix = parts[0];
     }
     const key = `${prefix}.Dynamic Event ${i + 1}`;
+    if (options.warnings) {
+      options.warnings.push({
+        type: "dynamic-event",
+        message: "Dynamic event listener detected",
+        detail: `Event listener with dynamic name`,
+        location: { file: r.sourceContext?.file, line: r.sourceContext?.startLine }
+      });
+    }
     channels[key] = {
       publish: {
         operationId: `dynamicEventWarning${i}`,
@@ -4337,7 +4986,8 @@ async function generateAsyncApi(rootRouter, options = {}) {
   return {
     asyncapi: "3.0.0",
     info: { title: "Shokupan AsyncAPI", version: "1.0.0", ...options.info },
-    channels
+    channels,
+    "x-middleware-registry": astMiddlewareRegistry
   };
 }
 const generator = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -4349,6 +4999,12 @@ class AsyncApiPlugin extends ShokupanRouter {
     super({ renderer: renderToString });
     this.pluginOptions = pluginOptions;
     this.pluginOptions.path ??= "/asyncapi";
+    this.metadata = {
+      file: import.meta.file,
+      line: 1,
+      name: "AsyncApiPlugin",
+      pluginName: "AsyncAPI"
+    };
     this.init();
   }
   static getBasePath() {
@@ -4761,12 +5417,15 @@ class ClusterPlugin {
     }
   }
 }
-function DashboardApp({ metrics, uptime, integrations, base, getRequestHeadersSource }) {
+function DashboardApp({ metrics, uptime, integrations, base, getRequestHeadersSource, rootPath, linkPattern }) {
   return /* @__PURE__ */ jsxs("html", { lang: "en", children: [
     /* @__PURE__ */ jsxs("head", { children: [
       /* @__PURE__ */ jsx("meta", { charSet: "UTF-8" }),
       /* @__PURE__ */ jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1.0" }),
       /* @__PURE__ */ jsx("title", { children: "Shokupan Debug Dashboard" }),
+      /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.googleapis.com" }),
+      /* @__PURE__ */ jsx("link", { rel: "preconnect", href: "https://fonts.gstatic.com", crossorigin: "anonymous" }),
+      /* @__PURE__ */ jsx("link", { href: "https://fonts.googleapis.com/css2?family=Google+Sans+Code:ital,wght@0,300..800;1,300..800&family=Vend+Sans:ital,wght@0,300..700;1,300..700&display=swap", rel: "stylesheet" }),
       /* @__PURE__ */ jsx("link", { href: "https://unpkg.com/tabulator-tables@5.5.0/dist/css/tabulator_bootstrap5.min.css", rel: "stylesheet" }),
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: "https://esm.sh/@xyflow/react@12.3.6/dist/style.css" }),
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/theme.css` }),
@@ -4775,104 +5434,134 @@ function DashboardApp({ metrics, uptime, integrations, base, getRequestHeadersSo
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/registry.css` }),
       /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/tabulator.css` }),
       /* @__PURE__ */ jsx("script", { src: "https://cdn.jsdelivr.net/npm/chart.js" }),
-      /* @__PURE__ */ jsx("script", { type: "text/javascript", src: "https://unpkg.com/tabulator-tables@5.5.0/dist/js/tabulator.min.js" })
+      /* @__PURE__ */ jsx("script", { type: "text/javascript", src: "https://unpkg.com/tabulator-tables@5.5.0/dist/js/tabulator.min.js" }),
+      /* @__PURE__ */ jsx("script", { src: "https://cdn.jsdelivr.net/npm/monaco-editor@0.44.0/min/vs/loader.js" })
     ] }),
     /* @__PURE__ */ jsxs("body", { children: [
       /* @__PURE__ */ jsxs("div", { class: "container", children: [
         /* @__PURE__ */ jsxs("header", { children: [
-          /* @__PURE__ */ jsxs("div", { children: [
-            /* @__PURE__ */ jsx("h1", { children: "Dashboard" }),
-            /* @__PURE__ */ jsxs("div", { style: "color: var(--text-secondary)", children: [
+          /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx("h1", { children: "Shokupan" }) }),
+          /* @__PURE__ */ jsxs("div", { style: "margin-left: 8px", children: [
+            /* @__PURE__ */ jsxs("span", { style: "color: var(--text-secondary)", children: [
               "Uptime: ",
               /* @__PURE__ */ jsx("span", { id: "uptime", children: uptime })
-            ] })
+            ] }),
+            /* @__PURE__ */ jsx("span", { id: "ws-status", title: "WebSocket: Disconnected", style: "width: 10px; height: 10px; border-radius: 50%; background: #6b7280; display: inline-block; margin-left: 10px;" })
           ] }),
+          /* @__PURE__ */ jsx("div", { style: "flex: 1;" }),
           /* @__PURE__ */ jsxs("div", { class: "tabs", children: [
             /* @__PURE__ */ jsx("button", { class: "tab-btn active", onclick: "switchTab('overview')", children: "Overview" }),
-            /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('registry')", children: "Registry" }),
-            /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('graph')", children: "Graph" }),
-            /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('requests')", children: "Requests" }),
-            /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('failures')", children: "Failures" }),
-            integrations.scalar && /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('scalar')", children: "API Reference" }),
-            integrations.asyncapi && /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('asyncapi')", children: "AsyncAPI" })
+            /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('application')", children: "Application" }),
+            /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('network')", children: "Network" }),
+            integrations.scalar && /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('scalar')", children: "Scalar" }),
+            integrations.apiExplorer && /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('api-explorer')", children: "REST API" }),
+            integrations.asyncapi && /* @__PURE__ */ jsx("button", { class: "tab-btn", onclick: "switchTab('asyncapi')", children: "WS API" })
           ] })
         ] }),
-        /* @__PURE__ */ jsxs("div", { id: "tab-overview", class: "tab-content active", children: [
-          /* @__PURE__ */ jsx(MetricsGrid, { metrics }),
-          /* @__PURE__ */ jsxs("div", { id: "chart-container", style: "display: flex; flex-direction: column; gap: 1rem;", children: [
-            /* @__PURE__ */ jsx("div", { style: "display: flex; justify-content: flex-end;", children: /* @__PURE__ */ jsxs("select", { id: "time-range-selector", onchange: "updateCharts(); updateDashboard(); fetchTopStats();", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); padding: 5px; border-radius: 4px;", children: [
-              /* @__PURE__ */ jsx("option", { value: "1m", children: "1 Minute" }),
-              /* @__PURE__ */ jsx("option", { value: "5m", children: "5 Minutes" }),
-              /* @__PURE__ */ jsx("option", { value: "30m", children: "30 Minutes" }),
-              /* @__PURE__ */ jsx("option", { value: "1h", children: "1 Hour" }),
-              /* @__PURE__ */ jsx("option", { value: "2h", children: "2 Hours" }),
-              /* @__PURE__ */ jsx("option", { value: "6h", children: "6 Hours" }),
-              /* @__PURE__ */ jsx("option", { value: "12h", children: "12 Hours" }),
-              /* @__PURE__ */ jsx("option", { value: "1d", children: "1 Day" }),
-              /* @__PURE__ */ jsx("option", { value: "3d", children: "3 Days" }),
-              /* @__PURE__ */ jsx("option", { value: "7d", children: "7 Days" }),
-              /* @__PURE__ */ jsx("option", { value: "30d", children: "30 Days" })
-            ] }) }),
-            /* @__PURE__ */ jsxs("div", { class: "card-container", children: [
-              /* @__PURE__ */ jsx(ChartCard, { title: "Response Time", id: "latencyChart" }),
-              /* @__PURE__ */ jsx(ChartCard, { title: "Requests / Second", id: "rpsChart" }),
-              /* @__PURE__ */ jsx(ChartCard, { title: "CPU & Load", id: "cpuChart" }),
-              /* @__PURE__ */ jsx(ChartCard, { title: "Memory", id: "memoryChart" }),
-              /* @__PURE__ */ jsx(ChartCard, { title: "Heap Usage", id: "heapChart" }),
-              /* @__PURE__ */ jsx(ChartCard, { title: "Event Loop Latency", id: "eventLoopChart" }),
-              /* @__PURE__ */ jsx(ChartCard, { title: "Error Rate", id: "errorRateChart" })
+        /* @__PURE__ */ jsxs("div", { class: "contents", children: [
+          /* @__PURE__ */ jsxs("div", { id: "tab-overview", class: "tab-content active", children: [
+            /* @__PURE__ */ jsx(MetricsGrid, { metrics }),
+            /* @__PURE__ */ jsxs("div", { id: "chart-container", style: "display: flex; flex-direction: column; gap: 1rem;", children: [
+              /* @__PURE__ */ jsx("div", { style: "display: flex; justify-content: flex-end;", children: /* @__PURE__ */ jsxs("select", { id: "time-range-selector", onchange: "updateCharts(); updateDashboard(); fetchTopStats();", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); padding: 5px; border-radius: 4px;", children: [
+                /* @__PURE__ */ jsx("option", { value: "1m", children: "1 Minute" }),
+                /* @__PURE__ */ jsx("option", { value: "5m", children: "5 Minutes" }),
+                /* @__PURE__ */ jsx("option", { value: "30m", children: "30 Minutes" }),
+                /* @__PURE__ */ jsx("option", { value: "1h", children: "1 Hour" }),
+                /* @__PURE__ */ jsx("option", { value: "2h", children: "2 Hours" }),
+                /* @__PURE__ */ jsx("option", { value: "6h", children: "6 Hours" }),
+                /* @__PURE__ */ jsx("option", { value: "12h", children: "12 Hours" }),
+                /* @__PURE__ */ jsx("option", { value: "1d", children: "1 Day" }),
+                /* @__PURE__ */ jsx("option", { value: "3d", children: "3 Days" }),
+                /* @__PURE__ */ jsx("option", { value: "7d", children: "7 Days" }),
+                /* @__PURE__ */ jsx("option", { value: "30d", children: "30 Days" })
+              ] }) }),
+              /* @__PURE__ */ jsxs("div", { class: "card-container", children: [
+                /* @__PURE__ */ jsx(ChartCard, { title: "Response Time", id: "latencyChart" }),
+                /* @__PURE__ */ jsx(ChartCard, { title: "Requests / Second", id: "rpsChart" }),
+                /* @__PURE__ */ jsx(ChartCard, { title: "CPU & Load", id: "cpuChart" }),
+                /* @__PURE__ */ jsx(ChartCard, { title: "Memory", id: "memoryChart" }),
+                /* @__PURE__ */ jsx(ChartCard, { title: "Heap Usage", id: "heapChart" }),
+                /* @__PURE__ */ jsx(ChartCard, { title: "Event Loop Latency", id: "eventLoopChart" }),
+                /* @__PURE__ */ jsx(ChartCard, { title: "Error Rate", id: "errorRateChart" })
+              ] }),
+              /* @__PURE__ */ jsx("div", { class: "card-title", style: "margin-top: 1rem;", children: "Top Statistics" }),
+              /* @__PURE__ */ jsxs("div", { class: "card-container", children: [
+                /* @__PURE__ */ jsx(Card, { title: "Top Requests", contentId: "top-requests-table" }),
+                /* @__PURE__ */ jsx(Card, { title: "Top Errors", contentId: "top-errors-table" }),
+                /* @__PURE__ */ jsx(Card, { title: "Most Frequent Failures", contentId: "failing-requests-table" }),
+                /* @__PURE__ */ jsx(Card, { title: "Slowest Requests", contentId: "slowest-requests-table" })
+              ] }),
+              /* @__PURE__ */ jsx("div", { id: "table-container", style: "padding: 0; margin-top: 1rem;", children: /* @__PURE__ */ jsx("div", { id: "requests-table", class: "table-dark" }) })
             ] }),
-            /* @__PURE__ */ jsx("div", { class: "card-title", style: "margin-top: 1rem;", children: "Top Statistics" }),
-            /* @__PURE__ */ jsxs("div", { class: "card-container", children: [
-              /* @__PURE__ */ jsx(Card, { title: "Top Requests", contentId: "top-requests-table" }),
-              /* @__PURE__ */ jsx(Card, { title: "Top Errors", contentId: "top-errors-table" }),
-              /* @__PURE__ */ jsx(Card, { title: "Most Frequent Failures", contentId: "failing-requests-table" }),
-              /* @__PURE__ */ jsx(Card, { title: "Slowest Requests", contentId: "slowest-requests-table" })
-            ] }),
-            /* @__PURE__ */ jsx("div", { id: "table-container", style: "padding: 0; margin-top: 1rem;", children: /* @__PURE__ */ jsx("div", { id: "requests-table", class: "table-dark" }) })
-          ] })
-        ] }),
-        /* @__PURE__ */ jsx("div", { id: "tab-registry", class: "tab-content", children: /* @__PURE__ */ jsxs("div", { id: "registry-container", class: "card", style: "margin-top: 2rem;", children: [
-          /* @__PURE__ */ jsx("div", { class: "card-title", children: "Component Registry" }),
-          /* @__PURE__ */ jsx("div", { id: "registry-tree", style: "padding: 0 1rem 1rem 1rem; font-family: monospace; font-size: 0.9rem;" })
-        ] }) }),
-        /* @__PURE__ */ jsxs("div", { id: "tab-graph", class: "tab-content", children: [
-          /* @__PURE__ */ jsx("div", { class: "card", style: "margin-bottom: 1rem;", children: /* @__PURE__ */ jsx("div", { style: "display: flex; gap: 1rem;", children: /* @__PURE__ */ jsx("input", { type: "text", id: "graph-search", placeholder: "Search routes or middleware...", "aria-label": "Search routes or middleware", style: "flex:1; padding: 0.5rem; border-radius: 0.5rem; background: var(--bg-primary); border: 1px solid var(--card-border); color: var(--text-primary);" }) }) }),
-          /* @__PURE__ */ jsx("div", { id: "cy" })
-        ] }),
-        /* @__PURE__ */ jsxs("div", { id: "tab-requests", class: "tab-content", children: [
-          /* @__PURE__ */ jsxs("div", { class: "card", style: "margin-bottom: 1rem; display: flex; justify-content: space-between; align-items: center;", children: [
-            /* @__PURE__ */ jsx("div", { class: "card-title", children: "Recent Requests (Last 100)" }),
-            /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx("button", { onclick: "fetchRequests()", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); padding: 5px 10px; border-radius: 4px; cursor: pointer;", children: "Refresh" }) })
+            /* @__PURE__ */ jsx("div", { style: "height: 2rem" })
           ] }),
-          /* @__PURE__ */ jsx("div", { id: "requests-list-container", style: "height: calc(100vh - 300px); margin-bottom: 2rem;" }),
-          /* @__PURE__ */ jsxs("div", { id: "request-details-container", class: "card", style: "display: none;", children: [
-            /* @__PURE__ */ jsx("div", { class: "card-title", children: "Request Details" }),
-            /* @__PURE__ */ jsx("div", { id: "request-details-content" }),
-            /* @__PURE__ */ jsx("div", { class: "card-title", style: "margin-top: 1rem;", children: "Middleware Trace" }),
-            /* @__PURE__ */ jsx("div", { id: "middleware-trace-container" })
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs("div", { id: "tab-failures", class: "tab-content", children: [
-          /* @__PURE__ */ jsxs("div", { class: "card", style: "margin-bottom: 1rem; display: flex; justify-content: space-between; align-items: center;", children: [
-            /* @__PURE__ */ jsx("div", { class: "card-title", children: "Failed Requests (Last 50)" }),
-            /* @__PURE__ */ jsxs("div", { children: [
-              /* @__PURE__ */ jsx("button", { onclick: "importFailure()", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); padding: 5px 10px; border-radius: 4px; cursor: pointer; margin-right: 8px;", children: "Import" }),
-              /* @__PURE__ */ jsx("button", { onclick: "fetchFailures()", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); padding: 5px 10px; border-radius: 4px; cursor: pointer;", children: "Refresh" })
+          /* @__PURE__ */ jsxs("div", { id: "tab-application", class: "tab-content", children: [
+            /* @__PURE__ */ jsx("div", { style: "margin: 2rem 2rem 0 2rem; display: flex; gap: 1rem; align-items: center;", children: /* @__PURE__ */ jsxs("div", { class: "button-group", children: [
+              /* @__PURE__ */ jsx("button", { class: "view-btn active", onclick: "switchApplicationView('registry')", children: "Registry" }),
+              /* @__PURE__ */ jsx("button", { class: "view-btn", onclick: "switchApplicationView('graph')", children: "Graph" })
+            ] }) }),
+            /* @__PURE__ */ jsxs("div", { id: "app-view-registry", class: "app-view active", style: "max-width: 1200px; align-self: center; margin: 0 auto", children: [
+              /* @__PURE__ */ jsxs("div", { id: "registry-container", class: "card", style: "margin: 2rem; margin-top: 1rem;", children: [
+                /* @__PURE__ */ jsx("div", { class: "card-title", children: "Component Registry" }),
+                /* @__PURE__ */ jsx("div", { id: "registry-tree", style: "padding: 0 1rem 1rem 1rem; font-family: monospace; font-size: 0.9rem;" })
+              ] }),
+              /* @__PURE__ */ jsx("div", { style: "height: .1px" })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { id: "app-view-graph", class: "app-view", style: "height: 100%;", children: [
+              /* @__PURE__ */ jsx("div", { class: "card", style: "margin: 1rem 2rem;", children: /* @__PURE__ */ jsx("div", { style: "display: flex; gap: 1rem;", children: /* @__PURE__ */ jsx("input", { type: "text", id: "graph-search", placeholder: "Search routes or middleware...", "aria-label": "Search routes or middleware", style: "flex:1; padding: 0.5rem; border-radius: 0.5rem; background: var(--bg-primary); border: 1px solid var(--card-border); color: var(--text-primary);" }) }) }),
+              /* @__PURE__ */ jsx("div", { id: "cy", style: "margin: 0 2rem; height: calc(100% - 10rem);" })
             ] })
           ] }),
-          /* @__PURE__ */ jsx("div", { id: "failures-table-container" })
-        ] }),
-        integrations.scalar && /* @__PURE__ */ jsx("div", { id: "tab-scalar", class: "tab-content", style: "margin: 0; overflow: hidden; height: 100%; max-width: unset", children: /* @__PURE__ */ jsx("iframe", { src: integrations.scalar, style: "width: 100%; height: 100%; border: none;" }) }),
-        integrations.asyncapi && /* @__PURE__ */ jsx("div", { id: "tab-asyncapi", class: "tab-content", style: "margin: 0; overflow: hidden; height: 100%; max-width: unset", children: /* @__PURE__ */ jsx("iframe", { src: integrations.asyncapi, style: "width: 100%; height: 100%; border: none;" }) })
+          /* @__PURE__ */ jsxs("div", { id: "tab-network", class: "tab-content", children: [
+            /* @__PURE__ */ jsx("div", { style: "margin: 1rem 2rem 0 2rem;", children: /* @__PURE__ */ jsxs("div", { id: "network-filter-bar", class: "card", style: "margin-bottom: 1rem; padding: 0.5rem; display: flex; gap: 0.5rem; flex-wrap: wrap; flex-direction: row", children: [
+              /* @__PURE__ */ jsxs("div", { style: "display: flex; background: var(--bg-secondary); border: 1px solid var(--card-border); border-radius: 4px; overflow: hidden;", children: [
+                /* @__PURE__ */ jsx("button", { class: "filter-direction active", "data-value": "all", style: "padding: 4px 12px; border: none; background: var(--bg-primary); color: var(--text-primary); cursor: pointer; border-right: 1px solid var(--card-border);", children: "All" }),
+                /* @__PURE__ */ jsx("button", { class: "filter-direction", "data-value": "inbound", style: "padding: 4px 12px; border: none; background: transparent; color: var(--text-secondary); cursor: pointer; border-right: 1px solid var(--card-border);", children: "Inbound" }),
+                /* @__PURE__ */ jsx("button", { class: "filter-direction", "data-value": "outbound", style: "padding: 4px 12px; border: none; background: transparent; color: var(--text-secondary); cursor: pointer;", children: "Outbound" })
+              ] }),
+              /* @__PURE__ */ jsx("input", { type: "text", id: "network-filter-text", placeholder: "Filter...", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); padding: 4px 8px; border-radius: 4px; flex: 1;" }),
+              /* @__PURE__ */ jsxs("select", { id: "network-filter-type", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); borderRadius: 4px;", children: [
+                /* @__PURE__ */ jsx("option", { value: "all", children: "All Types" }),
+                /* @__PURE__ */ jsx("option", { value: "xhr", children: "XHR/Fetch" }),
+                /* @__PURE__ */ jsx("option", { value: "fetch", children: "Outbound" }),
+                /* @__PURE__ */ jsx("option", { value: "ws", children: "WS" }),
+                /* @__PURE__ */ jsx("option", { value: "other", children: "Other" })
+              ] }),
+              /* @__PURE__ */ jsx("button", { onclick: "fetchRequests()", style: "background: var(--bg-primary); color: var(--text-primary); border: 1px solid var(--card-border); padding: 4px 8px; border-radius: 4px; cursor: pointer;", children: "Refresh" }),
+              /* @__PURE__ */ jsx("button", { onclick: "purgeRequests()", style: "background: var(--bg-primary); color: var(--color-error, #ef4444); border: 1px solid var(--card-border); padding: 4px 8px; border-radius: 4px; cursor: pointer;", children: "Purge" })
+            ] }) }),
+            /* @__PURE__ */ jsx("div", { id: "network-view", class: "active", style: "display: block; height: calc(100vh - 170px);", children: /* @__PURE__ */ jsxs("div", { style: "margin: 0 2rem; display: flex; gap: 1rem; height: 100%;", children: [
+              /* @__PURE__ */ jsx("div", { id: "requests-list-container", style: "flex: 1; height: 100%; border-radius: 6px; overflow: hidden; border: 1px solid var(--card-border);" }),
+              /* @__PURE__ */ jsxs("div", { id: "request-details-container", class: "card", style: "display: none; width: 500px; height: 100%; overflow-y: auto; flex-shrink: 0; background: var(--bg-secondary); border: 1px solid var(--card-border); position: relative;", children: [
+                /* @__PURE__ */ jsx("div", { id: "details-drag-handle", style: "position: absolute; left: 0; top: 0; bottom: 0; width: 5px; cursor: col-resize; z-index: 11; background: transparent;" }),
+                /* @__PURE__ */ jsxs("div", { style: "display: flex; justify-content: space-between; align-items: center; position: sticky; top: 0; background: var(--bg-secondary); padding: 0.5rem 1rem; border-bottom: 1px solid var(--border-color); z-index: 10;", children: [
+                  /* @__PURE__ */ jsx("div", { class: "card-title", style: "margin: 0;", children: "Request Details" }),
+                  /* @__PURE__ */ jsx("button", { onclick: "closeRequestDetails()", style: "background: transparent; border: none; color: var(--text-secondary); cursor: pointer; font-size: 1.2rem;", children: "×" })
+                ] }),
+                /* @__PURE__ */ jsxs("div", { style: "padding: 1rem;", children: [
+                  /* @__PURE__ */ jsx("div", { id: "request-details-content" }),
+                  /* @__PURE__ */ jsx("div", { class: "card-title", style: "margin-top: 1rem;", children: "Middleware Trace" }),
+                  /* @__PURE__ */ jsx("div", { id: "middleware-trace-container" })
+                ] })
+              ] })
+            ] }) })
+          ] }),
+          integrations.scalar && /* @__PURE__ */ jsx("div", { id: "tab-scalar", class: "tab-content", style: "overflow: hidden; height: 100%; width: 100%", children: /* @__PURE__ */ jsx("iframe", { src: integrations.scalar, style: "width: 100%; height: 100%; border: none;" }) }),
+          integrations.apiExplorer && /* @__PURE__ */ jsx("div", { id: "tab-api-explorer", class: "tab-content", style: "overflow: hidden; height: 100%; width: 100%", children: /* @__PURE__ */ jsx("iframe", { src: integrations.apiExplorer, style: "width: 100%; height: 100%; border: none;" }) }),
+          integrations.asyncapi && /* @__PURE__ */ jsx("div", { id: "tab-asyncapi", class: "tab-content", style: "overflow: hidden; height: 100%; width: 100%", children: /* @__PURE__ */ jsx("iframe", { src: integrations.asyncapi, style: "width: 100%; height: 100%; border: none;" }) })
+        ] })
       ] }),
       /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: {
         __html: `
                     // Injected function from server config
                     const getRequestHeaders = ${getRequestHeadersSource};
+                    window.SHOKUPAN_CONFIG = {
+                        rootPath: "${rootPath || ""}",
+                        linkPattern: "${linkPattern || ""}"
+                    };
                 `
       } }),
-      /* @__PURE__ */ jsx("script", { src: `${base}/poll.js` }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/client.js` }),
       /* @__PURE__ */ jsx("script", { src: `${base}/graph.mjs`, type: "module" }),
       /* @__PURE__ */ jsx("script", { src: `${base}/charts.js` }),
       /* @__PURE__ */ jsx("script", { src: `${base}/tables.js` }),
@@ -4942,6 +5631,264 @@ function Card({ title, contentId }) {
     /* @__PURE__ */ jsx("div", { id: contentId })
   ] });
 }
+const require$1 = createRequire(import.meta.url);
+const http = require$1("node:http");
+const https = require$1("node:https");
+class FetchInterceptor {
+  originalFetch;
+  originalHttpRequest;
+  originalHttpsRequest;
+  callbacks = [];
+  isPatched = false;
+  constructor() {
+    this.originalFetch = global.fetch;
+    this.originalHttpRequest = http.request;
+    this.originalHttpsRequest = https.request;
+  }
+  /**
+   * Patches the global `fetch` function to intercept requests.
+   * If already patched, this method does nothing.
+   */
+  patch() {
+    if (this.isPatched) return;
+    this.patchGlobalFetch();
+    this.patchNodeRequests();
+    this.isPatched = true;
+    console.log("[FetchInterceptor] Network layer patched.");
+  }
+  patchGlobalFetch() {
+    const self = this;
+    const newFetch = async function(input, init) {
+      const startTime = performance.now();
+      const timestamp = Date.now();
+      let method = "GET";
+      let url = "";
+      let requestHeaders = {};
+      let requestBody = void 0;
+      try {
+        if (input instanceof URL$1) {
+          url = input.toString();
+        } else if (typeof input === "string") {
+          url = input;
+        } else if (typeof input === "object" && "url" in input) {
+          url = input.url;
+          method = input.method;
+        }
+        if (init) {
+          if (init.method) method = init.method;
+          if (init.headers) {
+            if (init.headers instanceof Headers) {
+              init.headers.forEach((v, k) => requestHeaders[k] = v);
+            } else if (Array.isArray(init.headers)) {
+              init.headers.forEach(([k, v]) => requestHeaders[k] = v);
+            } else {
+              Object.assign(requestHeaders, init.headers);
+            }
+          }
+          if (init.body) requestBody = init.body;
+        }
+      } catch (e) {
+        console.warn("[FetchInterceptor] Failed to parse request arguments", e);
+      }
+      try {
+        const response = await self.originalFetch.apply(global, [input, init]);
+        const clone = response.clone();
+        const duration = performance.now() - startTime;
+        self.processResponse(clone, {
+          method,
+          url,
+          requestHeaders,
+          requestBody,
+          status: response.status,
+          startTime: timestamp,
+          duration,
+          ...self.extractRequestMeta(url, requestHeaders),
+          protocol: "1.1"
+          // native fetch doesn't expose this easily, assume 1.1/2
+        });
+        return response;
+      } catch (error) {
+        const duration = performance.now() - startTime;
+        self.notify({
+          method,
+          url,
+          requestHeaders,
+          requestBody,
+          status: 0,
+          responseHeaders: {},
+          responseBody: `Network Error: ${String(error)}`,
+          startTime: timestamp,
+          duration
+        });
+        throw error;
+      }
+    };
+    Object.assign(newFetch, this.originalFetch);
+    global.fetch = newFetch;
+  }
+  patchNodeRequests() {
+    const self = this;
+    const intercept = (module, original, defaultScheme) => {
+      module.request = function(...args) {
+        const startTime = performance.now();
+        const timestamp = Date.now();
+        let options = {};
+        let urlObj;
+        if (typeof args[0] === "string" || args[0] instanceof URL$1) {
+          try {
+            urlObj = new URL$1(args[0]);
+            options = typeof args[1] === "object" ? args[1] : {};
+          } catch (e) {
+          }
+        } else {
+          options = args[0] || {};
+          try {
+            const protocol = options.protocol || defaultScheme + ":";
+            const host = options.hostname || options.host || "localhost";
+            const port = options.port ? ":" + options.port : "";
+            const path = options.path || "/";
+            urlObj = new URL$1(`${protocol}//${host}${port}${path}`);
+          } catch (e) {
+          }
+        }
+        const method = (options.method || "GET").toUpperCase();
+        const url = urlObj ? urlObj.toString() : "unknown";
+        const req = original.apply(this, args);
+        const getReqHeaders = () => {
+          try {
+            const h = req.getHeaders();
+            const normalized = {};
+            for (const k in h) {
+              const v = h[k];
+              normalized[k] = Array.isArray(v) ? v.join(", ") : String(v);
+            }
+            return normalized;
+          } catch (e) {
+            return {};
+          }
+        };
+        req.on("response", (res) => {
+          const duration = performance.now() - startTime;
+          const resHeaders = {};
+          if (res.headers) {
+            for (const k in res.headers) {
+              const v = res.headers[k];
+              resHeaders[k] = Array.isArray(v) ? v.join(", ") : String(v || "");
+            }
+          }
+          self.notify({
+            method,
+            url,
+            requestHeaders: getReqHeaders(),
+            status: res.statusCode || 0,
+            responseHeaders: resHeaders,
+            startTime: timestamp,
+            duration,
+            ...self.extractRequestMeta(url, getReqHeaders()),
+            protocol: req.httpVersion
+          });
+        });
+        req.on("error", (err) => {
+          const duration = performance.now() - startTime;
+          self.notify({
+            method,
+            url,
+            requestHeaders: getReqHeaders(),
+            status: 0,
+            responseHeaders: {},
+            responseBody: `Error: ${err.message}`,
+            // Capture error
+            startTime: timestamp,
+            duration
+          });
+        });
+        return req;
+      };
+    };
+    intercept(http, this.originalHttpRequest, "http");
+    intercept(https, this.originalHttpsRequest, "https");
+  }
+  /**
+   * Restores the original functions.
+   */
+  unpatch() {
+    if (!this.isPatched) return;
+    global.fetch = this.originalFetch;
+    http.request = this.originalHttpRequest;
+    https.request = this.originalHttpsRequest;
+    this.isPatched = false;
+    console.log("[FetchInterceptor] Network layer restored.");
+  }
+  /**
+   * Adds a callback to be notified of outbound requests.
+   * @param callback The callback function.
+   */
+  on(callback) {
+    this.callbacks.push(callback);
+  }
+  extractRequestMeta(urlStr, headers) {
+    try {
+      const url = new URL$1(urlStr);
+      const cookiesHeader = headers["cookie"] || headers["Cookie"];
+      const cookies = cookiesHeader ? cookiesHeader.split(";").length : 0;
+      return {
+        domain: url.hostname,
+        path: url.pathname,
+        scheme: url.protocol.replace(":", ""),
+        cookies,
+        remoteIP: void 0
+        // Not easily accessible via fetch
+      };
+    } catch (e) {
+      return {};
+    }
+  }
+  async processResponse(response, meta) {
+    const responseHeaders = {};
+    response.headers.forEach((v, k) => responseHeaders[k] = v);
+    let responseBody;
+    let transferred = 0;
+    try {
+      const contentType = response.headers.get("content-type") || "";
+      let bodyText = "";
+      if (contentType.includes("application/json") || contentType.includes("text/")) {
+        bodyText = await response.text();
+        if (bodyText.length > 524288) {
+          responseBody = bodyText.substring(0, 524288) + "... (truncated)";
+        } else {
+          responseBody = bodyText;
+        }
+      } else {
+        responseBody = "[Binary Content]";
+        const cl = response.headers.get("content-length");
+        if (cl) transferred = parseInt(cl, 10);
+      }
+      const headersSize = Object.entries(responseHeaders).reduce((acc, [k, v]) => acc + k.length + v.length + 2, 0);
+      if (!transferred && bodyText) {
+        transferred = headersSize + bodyText.length;
+      } else if (!transferred) {
+        transferred = headersSize;
+      }
+    } catch (e) {
+      responseBody = "[Failed to read response body]";
+    }
+    this.notify({
+      ...meta,
+      responseHeaders,
+      responseBody,
+      transferred
+    });
+  }
+  notify(log) {
+    this.callbacks.forEach((cb) => {
+      try {
+        cb(log);
+      } catch (e) {
+        console.error("[FetchInterceptor] Callback failed", e);
+      }
+    });
+  }
+}
 const INTERVALS = [
   { label: "10s", ms: 10 * 1e3 },
   { label: "1m", ms: 60 * 1e3 },
@@ -4956,7 +5903,8 @@ const INTERVALS = [
   { label: "30d", ms: 30 * 24 * 60 * 60 * 1e3 }
 ];
 class MetricsCollector {
-  constructor(db) {
+  constructor(db, onCollect) {
+    this.onCollect = onCollect;
     this.db = db;
     this.eventLoopHistogram.enable();
     const now = Date.now();
@@ -4964,11 +5912,13 @@ class MetricsCollector {
       this.currentIntervalStart[int.label] = this.alignTimestamp(now, int.ms);
       this.pendingDetails[int.label] = [];
     });
+    this.timer = setInterval(() => this.collect(), 1e4);
   }
   currentIntervalStart = {};
   pendingDetails = {};
   eventLoopHistogram = monitorEventLoopDelay({ resolution: 10 });
   timer = null;
+  db;
   recordRequest(duration, isError) {
     INTERVALS.forEach((int) => {
       this.pendingDetails[int.label].push({ duration, isError });
@@ -5044,14 +5994,17 @@ class MetricsCollector {
         p99: getP(0.99)
       }
     };
+    if (!this.db) {
+      return;
+    }
     try {
-      const recordId = new RecordId("metrics", timestamp);
-      await this.db.upsert(recordId, metric);
-      const test = await this.db.select(recordId);
-      const queryTest = await this.db.query("SELECT * FROM metrics WHERE id = $id", { id: recordId });
+      await this.db.upsert(new RecordId("metric", timestamp), metric);
     } catch (e) {
       console.error(`[MetricsCollector] ✗ Failed to save metrics for ${label}:`, e);
     }
+    if (this.onCollect) {
+      this.onCollect(metric);
+    }
   }
   // Cleanup if needed
   stop() {
@@ -5097,8 +6050,13 @@ class Dashboard {
     nodeMetrics: {},
     edgeMetrics: {}
   };
+  clients = /* @__PURE__ */ new Set();
+  broadcastTimer;
+  requestPushTimer;
+  requestsBuffer = [];
   startTime = Date.now();
   instrumented = false;
+  mountPath = "/dashboard";
   metricsCollector;
   get db() {
     return this[$appRoot].db;
@@ -5106,8 +6064,69 @@ class Dashboard {
   // ShokupanPlugin interface implementation
   onInit(app, options) {
     this[$appRoot] = app;
-    this.metricsCollector = new MetricsCollector(this.db);
-    const mountPath = options?.path || this.dashboardConfig.path || "/dashboard";
+    const onCollect = (metric) => {
+      this.broadcastMetricUpdate(metric);
+    };
+    this.metricsCollector = new MetricsCollector(this.db, onCollect);
+    const fetchInterceptor = new FetchInterceptor();
+    fetchInterceptor.patch();
+    fetchInterceptor.on((log) => {
+      if (log.url.includes("/rpc")) return;
+      try {
+        const u = new URL(log.url);
+        if (u.pathname.startsWith(this.mountPath)) return;
+      } catch (e) {
+      }
+      const requestData = {
+        method: log.method,
+        url: log.url,
+        status: log.status,
+        duration: log.duration,
+        timestamp: log.startTime,
+        // Use startTime as timestamp
+        type: "fetch",
+        direction: "outbound",
+        size: log.responseBody ? String(log.responseBody).length : 0,
+        contentType: log.responseHeaders["content-type"] || log.responseHeaders["Content-Type"],
+        body: log.responseBody,
+        requestBody: log.requestBody,
+        domain: log.domain,
+        path: log.path,
+        scheme: log.scheme,
+        protocol: log.protocol,
+        remoteIP: log.remoteIP,
+        cookies: log.cookies,
+        transferred: log.transferred,
+        requestHeaders: log.requestHeaders,
+        responseHeaders: log.responseHeaders
+        // No handler stack for outbound
+      };
+      this.metrics.logs.push(requestData);
+      const recordId = new RecordId("request", nanoid());
+      const idString = recordId.toString();
+      this.db.query("UPSERT $id CONTENT $data", {
+        id: recordId,
+        data: requestData
+      }).catch((e) => console.error("Failed to save outbound request", e));
+      const strategy2 = this.dashboardConfig.updateStrategy || "immediate";
+      if (strategy2 === "immediate") {
+        this.broadcastRequestUpdates([{ ...requestData, id: idString }]);
+      } else {
+        this.requestsBuffer.push({ ...requestData, id: idString });
+      }
+    });
+    if (app.onStart) {
+      app.onStart(async () => {
+        if (app.dbPromise) {
+          await app.dbPromise;
+          if (app.db) {
+            this.metricsCollector.db = app.db;
+            console.log("[Dashboard] Attached datastore to MetricsCollector");
+          }
+        }
+      });
+    }
+    this.mountPath = options?.path || this.dashboardConfig.path || "/dashboard";
     const hooks = this.getHooks();
     if (!app.middleware) {
       app.middleware = [];
@@ -5116,15 +6135,25 @@ class Dashboard {
       if (hooks.onRequestStart) {
         await hooks.onRequestStart(ctx);
       }
+      ctx._startTime = performance.now();
       await next();
-      if (hooks.onResponseEnd) {
-        const effectiveResponse = ctx._finalResponse || ctx.response || {};
-        await hooks.onResponseEnd(ctx, effectiveResponse);
-      }
     };
     app.use(hooksMiddleware);
-    app.mount(mountPath, this.router);
+    if (hooks.onResponseEnd) {
+      app.hook("onResponseEnd", hooks.onResponseEnd);
+    }
+    app.mount(this.mountPath, this.router);
+    this.router.metadata = {
+      file: import.meta.file,
+      line: 1,
+      name: "DashboardPlugin",
+      pluginName: "Dashboard"
+    };
     this.setupRoutes();
+    const strategy = this.dashboardConfig.updateStrategy || "immediate";
+    if (strategy === "batched") {
+      this.startRequestPushTimer();
+    }
   }
   detectIntegrations() {
     const integrations = {};
@@ -5157,6 +6186,17 @@ class Dashboard {
         }
       }
     }
+    const apiExplorerConf = checkConfig("apiExplorer");
+    if (apiExplorerConf.enabled) {
+      if (apiExplorerConf.path) {
+        integrations["apiExplorer"] = apiExplorerConf.path;
+      } else {
+        const plugin = routers.find((r) => r.constructor.name === "ApiExplorerPlugin");
+        if (plugin) {
+          integrations["apiExplorer"] = plugin[$mountPath];
+        }
+      }
+    }
     return integrations;
   }
   // Get base path for dashboard files - works in both dev (src/) and production (dist/)
@@ -5168,9 +6208,36 @@ class Dashboard {
     return dir;
   }
   setupRoutes() {
+    this.router.get("/ws", (ctx) => {
+      const success = ctx.upgrade({
+        data: {
+          handler: {
+            open: (ws) => {
+              this.clients.add(ws);
+              console.log(`[Dashboard] Client connected. Total clients: ${this.clients.size}`);
+              this.sendHistory(ws, "1m");
+            },
+            close: (ws) => {
+              this.clients.delete(ws);
+              console.log(`[Dashboard] Client disconnected. Total clients: ${this.clients.size}`);
+            },
+            message: (ws, message) => {
+              try {
+                const msg = JSON.parse(message);
+                if (msg.type === "get-history") {
+                  this.sendHistory(ws, msg.interval || "1m");
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
+      });
+      if (success) return void 0;
+      return ctx.text("WebSocket upgrade failed", 400);
+    });
     this.router.get("/metrics", async (ctx) => {
-      const uptimeSeconds = Math.floor((Date.now() - this.startTime) / 1e3);
-      const uptime = `${Math.floor(uptimeSeconds / 3600)}h ${Math.floor(uptimeSeconds % 3600 / 60)}m ${uptimeSeconds % 60}s`;
+      const uptime = this.getUptime();
       const interval = ctx.query["interval"];
       if (interval) {
         const intervalMap = {
@@ -5197,13 +6264,15 @@ class Dashboard {
                             count(IF status < 400 THEN 1 END) as success,
                             count(IF status >= 400 THEN 1 END) as failed,
                             math::mean(duration) as avg_latency
-                        FROM requests 
+                        FROM request 
                         WHERE timestamp >= $start
                         GROUP ALL
                     `, { start: startTime });
         } catch (error) {
           console.error("[Dashboard] Query failed at plugin.ts:180-191", {
             error,
+            errorMessage: error.message,
+            errorStack: error.stack,
             interval,
             startTime,
             query: "metrics interval stats",
@@ -5211,12 +6280,12 @@ class Dashboard {
           });
           throw error;
         }
-        const s = stats[0] || { total: 0, success: 0, failed: 0, avg_latency: 0 };
+        const s = stats[0] || { avg_latency: 0 };
         return ctx.json({
           metrics: {
-            totalRequests: s.total || 0,
-            successfulRequests: s.success || 0,
-            failedRequests: s.failed || 0,
+            totalRequests: this.metrics.totalRequests,
+            successfulRequests: this.metrics.successfulRequests,
+            failedRequests: this.metrics.failedRequests,
             activeRequests: this.metrics.activeRequests,
             averageTotalTime_ms: s.avg_latency || 0,
             recentTimings: this.metrics.recentTimings,
@@ -5282,7 +6351,7 @@ class Dashboard {
     this.router.get("/requests/top", async (ctx) => {
       const startTime = getIntervalStartTime(ctx.query["interval"]);
       const result = await this.db.query(
-        "SELECT method, url, count() as count FROM requests WHERE timestamp >= $start GROUP BY method, url ORDER BY count DESC LIMIT 10",
+        "SELECT method, url, count() as count FROM request WHERE timestamp >= $start GROUP BY method, url ORDER BY count DESC LIMIT 10",
         { start: startTime }
       );
       return ctx.json({ top: result[0] || [] });
@@ -5290,7 +6359,7 @@ class Dashboard {
     this.router.get("/errors/top", async (ctx) => {
       const startTime = getIntervalStartTime(ctx.query["interval"]);
       const result = await this.db.query(
-        "SELECT status, count() as count FROM failed_requests WHERE timestamp >= $start GROUP BY status ORDER BY count DESC LIMIT 10",
+        "SELECT status, count() as count FROM failed_request WHERE timestamp >= $start GROUP BY status ORDER BY count DESC LIMIT 10",
         { start: startTime }
       );
       return ctx.json({ top: result[0] || [] });
@@ -5298,7 +6367,7 @@ class Dashboard {
     this.router.get("/requests/failing", async (ctx) => {
       const startTime = getIntervalStartTime(ctx.query["interval"]);
       const result = await this.db.query(
-        "SELECT method, url, count() as count FROM failed_requests WHERE timestamp >= $start GROUP BY method, url ORDER BY count DESC LIMIT 10",
+        "SELECT method, url, count() as count FROM failed_request WHERE timestamp >= $start GROUP BY method, url ORDER BY count DESC LIMIT 10",
         { start: startTime }
       );
       return ctx.json({ top: result[0] || [] });
@@ -5306,7 +6375,7 @@ class Dashboard {
     this.router.get("/requests/slowest", async (ctx) => {
       const startTime = getIntervalStartTime(ctx.query["interval"]);
       const result = await this.db.query(
-        "SELECT method, url, duration, status, timestamp FROM requests WHERE timestamp >= $start ORDER BY duration DESC LIMIT 10",
+        "SELECT method, url, duration, status, timestamp FROM request WHERE timestamp >= $start ORDER BY duration DESC LIMIT 10",
         { start: startTime }
       );
       return ctx.json({ slowest: result[0] || [] });
@@ -5323,15 +6392,32 @@ class Dashboard {
       return ctx.json({ registry: registry || {} });
     });
     this.router.get("/requests", async (ctx) => {
-      const result = await this.db.query("SELECT * FROM requests ORDER BY timestamp DESC LIMIT 100");
-      return ctx.json({ requests: result[0] || [] });
+      console.log(`[Dashboard] Handling /requests from ${ctx.ip} ${ctx.get("User-Agent")}`);
+      const result = await this.db.query("SELECT * FROM request ORDER BY timestamp DESC LIMIT 100");
+      const items = result[0] || [];
+      console.log(`[Dashboard] /requests returning ${items.length} items`);
+      return ctx.json({ requests: items });
+    });
+    this.router.delete("/requests", async (ctx) => {
+      console.log(`[Dashboard] Purging all requests`);
+      await this.db.query("DELETE request; DELETE failed_request;");
+      this.metrics.logs = [];
+      this.metrics.totalRequests = 0;
+      this.metrics.activeRequests = 0;
+      this.metrics.successfulRequests = 0;
+      this.metrics.failedRequests = 0;
+      this.metrics.recentTimings = [];
+      this.metrics.rateLimitedCounts = {};
+      this.metrics.nodeMetrics = {};
+      this.metrics.edgeMetrics = {};
+      return ctx.json({ success: true });
     });
     this.router.get("/requests/:id", async (ctx) => {
-      const result = await this.db.query("SELECT * FROM requests WHERE id = $id", { id: ctx.params["id"] });
+      const result = await this.db.query("SELECT * FROM request WHERE id = $id", { id: ctx.params["id"] });
       return ctx.json({ request: result[0]?.[0] });
     });
     this.router.get("/failures", async (ctx) => {
-      const result = await this.db.query("SELECT * FROM failed_requests ORDER BY timestamp DESC LIMIT 50");
+      const result = await this.db.query("SELECT * FROM failed_request ORDER BY timestamp DESC LIMIT 50");
       return ctx.json({ failures: result[0] });
     });
     this.router.post("/replay", async (ctx) => {
@@ -5369,7 +6455,7 @@ class Dashboard {
         "charts.js",
         "failures.js",
         "graph.mjs",
-        "poll.js",
+        "client.js",
         "reactflow.css",
         "registry.css",
         "registry.js",
@@ -5386,15 +6472,15 @@ class Dashboard {
         else if (path.endsWith(".js") || path.endsWith(".mjs")) ctx.set("Content-Type", "application/javascript");
         return ctx.send(content);
       }
-      const uptimeSeconds = Math.floor((Date.now() - this.startTime) / 1e3);
-      const uptime = `${Math.floor(uptimeSeconds / 3600)}h ${Math.floor(uptimeSeconds % 3600 / 60)}m ${uptimeSeconds % 60}s`;
-      this.getLinkPattern();
+      const uptime = this.getUptime();
+      const linkPattern = this.getLinkPattern();
       const integrations = this.detectIntegrations();
       const getRequestHeadersSource = this.dashboardConfig.getRequestHeaders ? this.dashboardConfig.getRequestHeaders.toString() : "undefined";
       const html = renderToString(DashboardApp({
         metrics: this.metrics,
         uptime,
         rootPath: process.cwd(),
+        linkPattern,
         integrations,
         base: mountPath,
         getRequestHeadersSource
@@ -5402,6 +6488,82 @@ class Dashboard {
       return ctx.html(`<!DOCTYPE html>${html}`);
     });
   }
+  getUptime() {
+    const uptimeSeconds = Math.floor((Date.now() - this.startTime) / 1e3);
+    return `${Math.floor(uptimeSeconds / 3600)}h ${Math.floor(uptimeSeconds % 3600 / 60)}m ${uptimeSeconds % 60}s`;
+  }
+  getPublicMetrics() {
+    return {
+      totalRequests: this.metrics.totalRequests,
+      successfulRequests: this.metrics.successfulRequests,
+      failedRequests: this.metrics.failedRequests,
+      activeRequests: this.metrics.activeRequests,
+      averageTotalTime_ms: this.metrics.averageTotalTime_ms,
+      recentTimings: this.metrics.recentTimings,
+      logs: [],
+      // Don't broadcast logs for now to save bandwidth
+      rateLimitedCounts: this.metrics.rateLimitedCounts,
+      nodeMetrics: this.metrics.nodeMetrics,
+      edgeMetrics: this.metrics.edgeMetrics
+    };
+  }
+  broadcastMetricUpdate(metric) {
+    if (this.clients.size === 0) return;
+    const data = JSON.stringify({
+      type: "metric-update",
+      metric
+    });
+    for (const client of this.clients) {
+      client.send(data);
+    }
+  }
+  async sendHistory(ws, interval) {
+    const intervalMap = {
+      "10s": 10 * 1e3,
+      "1m": 60 * 1e3,
+      "5m": 5 * 60 * 1e3,
+      "30m": 30 * 60 * 1e3,
+      "1h": 60 * 60 * 1e3,
+      "2h": 2 * 60 * 60 * 1e3,
+      "6h": 6 * 60 * 60 * 1e3,
+      "12h": 12 * 60 * 60 * 1e3,
+      "1d": 24 * 60 * 60 * 1e3,
+      "3d": 3 * 24 * 60 * 60 * 1e3,
+      "7d": 7 * 24 * 60 * 60 * 1e3,
+      "30d": 30 * 24 * 60 * 60 * 1e3
+    };
+    const periodMs = intervalMap[interval] || 60 * 1e3;
+    const startTime = Date.now() - periodMs * 30;
+    const endTime = Date.now();
+    let history = [];
+    try {
+      const result = await this.db.query(
+        "SELECT * FROM metric WHERE timestamp >= $start AND timestamp <= $end AND interval = $interval ORDER BY timestamp ASC",
+        { start: startTime, end: endTime, interval }
+      );
+      history = result[0] || [];
+    } catch (e) {
+      console.error("[Dashboard] Failed to fetch history for WS", e);
+    }
+    ws.send(JSON.stringify({
+      type: "init",
+      metrics: { ...this.metrics, logs: [] },
+      uptime: this.getUptime(),
+      history
+    }));
+  }
+  broadcastMetrics() {
+    if (this.clients.size === 0) return;
+    console.log(`[Dashboard] Broadcasting metrics to ${this.clients.size} clients`);
+    const data = JSON.stringify({
+      type: "metrics",
+      metrics: this.getPublicMetrics(),
+      uptime: this.getUptime()
+    });
+    for (const client of this.clients) {
+      client.send(data);
+    }
+  }
   instrumentApp(app) {
     if (!app.getComponentRegistry) return;
     const registry = app.getComponentRegistry();
@@ -5431,6 +6593,11 @@ class Dashboard {
       r.id = id;
       this.assignIdsToRegistry(r.children, id);
     });
+    node.events?.forEach((e, idx) => {
+      const id = makeId("event", parentId, idx, e.name);
+      e.id = id;
+      if (e._fn) e._fn._debugId = id;
+    });
   }
   recordNodeMetric(id, type, duration, isError) {
     if (!this.metrics.nodeMetrics[id]) {
@@ -5458,7 +6625,7 @@ class Dashboard {
     if (["vscode", "cursor", "antigravity"].some((t) => term.includes(t))) {
       return "vscode://file/{{absolute}}:{{line}}";
     }
-    return "file:///{{absolute}}:{{line}}";
+    return "vscode://file/{{absolute}}:{{line}}";
   }
   getHooks() {
     return {
@@ -5469,19 +6636,36 @@ class Dashboard {
         }
         this.metrics.totalRequests++;
         this.metrics.activeRequests++;
-        ctx._debugStartTime = performance.now();
         ctx[$debug] = new Collector(this);
+        if (!this.broadcastTimer) {
+          this.broadcastTimer = setTimeout(() => {
+            this.broadcastMetrics();
+            this.broadcastTimer = void 0;
+          }, 100);
+        }
       },
       onResponseEnd: async (ctx, response) => {
+        if (ctx.path.startsWith(this.mountPath)) return;
         this.metrics.activeRequests = Math.max(0, this.metrics.activeRequests - 1);
-        const start = ctx._debugStartTime;
-        let duration = 0;
-        if (start) {
-          duration = performance.now() - start;
-          this.updateTiming(duration);
+        const duration = performance.now() - ctx._startTime || 0;
+        if (!response) {
+          if (ctx.isUpgraded) {
+            response = {
+              status: 101,
+              headers: {}
+            };
+          } else {
+            return;
+          }
         }
         const isError = response.status >= 400;
         this.metricsCollector.recordRequest(duration, isError);
+        if (!this.broadcastTimer) {
+          this.broadcastTimer = setTimeout(() => {
+            this.broadcastMetrics();
+            this.broadcastTimer = void 0;
+          }, 100);
+        }
         if (response.status >= 400) {
           this.metrics.failedRequests++;
           if (response.status === 429) {
@@ -5489,20 +6673,28 @@ class Dashboard {
             this.metrics.rateLimitedCounts[path] = (this.metrics.rateLimitedCounts[path] || 0) + 1;
           }
           try {
-            const headers = {};
+            const headers2 = {};
             if (ctx.request.headers && typeof ctx.request.headers.forEach === "function") {
               ctx.request.headers.forEach((v, k) => {
-                headers[k] = v;
+                headers2[k] = v;
+              });
+            }
+            const resHeaders2 = {};
+            if (response.headers && typeof response.headers.forEach === "function") {
+              response.headers.forEach((v, k) => {
+                resHeaders2[k] = v;
               });
             }
-            await this.db.upsert(new RecordId("failed_requests", ctx.requestId), {
+            await this.db.upsert(new RecordId(`failed_request`, ctx.requestId), {
               method: ctx.method,
               url: ctx.url.toString(),
-              headers,
+              headers: headers2,
               status: response.status,
               timestamp: Date.now(),
-              state: ctx.state
-              // body?
+              state: ctx.state,
+              body: this.serializeBody(ctx.bodyData || ctx.requestBody),
+              responseHeaders: resHeaders2,
+              responseBody: this.serializeBody(ctx.responseBody)
             });
           } catch (e) {
             console.error("Failed to record failed request", e);
@@ -5510,17 +6702,58 @@ class Dashboard {
         } else {
           this.metrics.successfulRequests++;
         }
+        const urlObj = new URL(ctx.url.toString());
+        const cookieHeader = ctx.request.headers.get("cookie") || "";
+        const cookiesCount = cookieHeader ? cookieHeader.split(";").length : 0;
+        const headers = {};
+        if (ctx.request.headers && typeof ctx.request.headers.forEach === "function") {
+          ctx.request.headers.forEach((v, k) => {
+            headers[k] = v;
+          });
+        }
+        const resHeaders = {};
+        if (response.headers && typeof response.headers.forEach === "function") {
+          response.headers.forEach((v, k) => {
+            resHeaders[k] = v;
+          });
+        }
+        const responseHeadersSize = Object.entries(response.headers || {}).reduce((acc, [k, v]) => acc + k.length + String(v).length + 2, 0);
+        const responseSize = ctx.responseBody ? String(ctx.responseBody).length : 0;
+        const remoteIP = ctx.request.headers.get("x-forwarded-for") || ctx.req?.socket?.remoteAddress;
         const logEntry = {
           method: ctx.method,
           url: ctx.url.toString(),
           status: response.status,
           duration,
           timestamp: Date.now(),
-          handlerStack: ctx.handlerStack
+          handlerStack: this.serializeHandlerStack(ctx.handlerStack),
+          body: this.serializeBody(ctx.responseBody),
+          requestBody: ctx.bodyData || ctx.requestBody,
+          // ShokupanContext usually stores parsed body here if parsed
+          contentType: response.headers["content-type"] || response.headers["Content-Type"],
+          type: "xhr",
+          direction: "inbound",
+          size: responseSize,
+          protocol: ctx.req?.httpVersion,
+          // Try to get protocol from raw request if available, Bun might expose it
+          domain: urlObj.hostname,
+          path: urlObj.pathname,
+          scheme: urlObj.protocol.replace(":", ""),
+          cookies: cookiesCount,
+          transferred: responseSize + responseHeadersSize,
+          remoteIP,
+          requestHeaders: headers,
+          responseHeaders: resHeaders
         };
         this.metrics.logs.push(logEntry);
         try {
-          await this.db.upsert(new RecordId("requests", ctx.requestId), logEntry);
+          await this.db.query("UPSERT $id CONTENT $data", {
+            id: new RecordId("request", ctx.requestId),
+            data: {
+              ...logEntry,
+              direction: "inbound"
+            }
+          });
         } catch (e) {
           console.error("Failed to record request log", e);
         }
@@ -5529,9 +6762,49 @@ class Dashboard {
         if (this.metrics.logs.length > 0 && this.metrics.logs[0].timestamp < cutoff) {
           this.metrics.logs = this.metrics.logs.filter((log) => log.timestamp >= cutoff);
         }
+        const requestData = {
+          id: ctx.requestId,
+          ...logEntry
+        };
+        const strategy = this.dashboardConfig.updateStrategy || "immediate";
+        if (strategy === "immediate") {
+          this.broadcastRequestUpdates([requestData]);
+        } else {
+          this.requestsBuffer.push(requestData);
+        }
       }
     };
   }
+  startRequestPushTimer() {
+    const interval = this.dashboardConfig.updateInterval || 1e4;
+    this.requestPushTimer = setInterval(() => {
+      if (this.requestsBuffer.length > 0) {
+        this.broadcastRequestUpdates();
+      }
+    }, interval);
+  }
+  broadcastRequestUpdates(requestsOverride) {
+    if (this.clients.size === 0) {
+      if (!requestsOverride) this.requestsBuffer = [];
+      return;
+    }
+    let requests;
+    if (requestsOverride) {
+      requests = requestsOverride;
+    } else {
+      requests = [...this.requestsBuffer];
+      this.requestsBuffer = [];
+    }
+    if (requests.length === 0) return;
+    console.log(`[Dashboard] Broadcasting ${requests.length} requests. Sample ID: ${requests[0].id}`);
+    const data = JSON.stringify({
+      type: "requests-update",
+      requests
+    });
+    for (const client of this.clients) {
+      client.send(data);
+    }
+  }
   updateTiming(duration) {
     const alpha = 0.1;
     if (this.metrics.averageTotalTime_ms === 0) {
@@ -5544,6 +6817,39 @@ class Dashboard {
       this.metrics.recentTimings.shift();
     }
   }
+  serializeHandlerStack(stack) {
+    if (!stack || !Array.isArray(stack)) return [];
+    return stack.map((item) => ({
+      name: item.name,
+      file: item.file,
+      line: item.line,
+      duration: item.duration,
+      startTime: item.startTime,
+      isBuiltin: item.isBuiltin
+      // stateChanges: item.stateChanges // Exclude complex objects for now
+    }));
+  }
+  serializeBody(body) {
+    if (!body) return void 0;
+    if (typeof body === "string") {
+      if (body.length > 524288) {
+        return body.substring(0, 524288) + "... (truncated)";
+      }
+      return body;
+    }
+    if (typeof body === "object") {
+      try {
+        const str = JSON.stringify(body);
+        if (str.length > 524288) {
+          return str.substring(0, 524288) + "... (truncated)";
+        }
+        return body;
+      } catch (e) {
+        return "[Circular or Non-Serializable Body]";
+      }
+    }
+    return "[Binary or Unreadable Body]";
+  }
 }
 function unknownError(ctx) {
   return ctx.json({ error: "Unknown Error" }, 500);
@@ -5627,6 +6933,12 @@ class ScalarPlugin extends ShokupanRouter {
     pluginOptions.config ??= {};
     super();
     this.pluginOptions = pluginOptions;
+    this.metadata = {
+      file: import.meta.file,
+      line: 1,
+      name: "ScalarPlugin",
+      pluginName: "Scalar"
+    };
     this.initRoutes();
   }
   eta;
@@ -5645,34 +6957,73 @@ class ScalarPlugin extends ShokupanRouter {
   }
   initRoutes() {
     const bootId = Date.now().toString();
-    this.get("/_lifecycle", (ctx) => ctx.json({ boot: bootId }));
+    this.get("/_lifecycle", (ctx) => {
+      const success = ctx.upgrade({
+        data: {
+          bootId,
+          handler: {
+            open: (ws) => {
+              ws.send(JSON.stringify({ type: "hello", bootId }));
+            }
+          }
+        }
+      });
+      if (success) return void 0;
+      return ctx.json({ boot: bootId });
+    });
     this.get("/", async (ctx) => {
       await this.ensureEta();
-      let path = ctx.url.toString();
+      let path = ctx.path;
       if (!path.endsWith("/")) path += "/";
       const devScript = ctx.app?.applicationConfig.development ? `
                 <script>
                     (function() {
                         const bootId = "${bootId}";
-                        let isDown = false;
+                        let ws;
+                        let reconnectTimer;
                         
-                        setInterval(async () => {
-                            try {
-                                const res = await fetch('${path}_lifecycle');
-                                if (!res.ok) throw new Error('Down');
-                                const data = await res.json();
-                                if (data.boot !== bootId) {
-                                    console.log('Server restarted, reloading...');
-                                    window.location.reload();
-                                }
-                                else if (isDown) {
-                                    isDown = false;
+                        function connect() {
+                            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+                            const wsUrl = protocol + '//' + window.location.host + '${path}_lifecycle';
+                            
+                            ws = new WebSocket(wsUrl);
+                            
+                            ws.onopen = () => {
+                                console.log('[Scalar] Connected to lifecycle monitor');
+                                if (reconnectTimer) {
+                                    clearTimeout(reconnectTimer);
+                                    reconnectTimer = undefined;
                                 }
-                            } catch (e) {
-                                isDown = true;
-                                console.log('Connection lost...');
-                            }
-                        }, 2000);
+                            };
+                            
+                            ws.onmessage = (event) => {
+                                try {
+                                    const data = JSON.parse(event.data);
+                                    if (data.type === 'hello') {
+                                        if (data.bootId !== bootId) {
+                                            console.log('[Scalar] Server restarted (timestamp change), reloading...');
+                                            window.location.reload();
+                                        }
+                                    }
+                                } catch (e) {}
+                            };
+                            
+                            ws.onclose = () => {
+                                console.log('[Scalar] Lifecycle connection lost');
+                                ws = undefined;
+                                scheduleReconnect();
+                            };
+                        }
+                        
+                        function scheduleReconnect() {
+                            if (reconnectTimer) return;
+                            reconnectTimer = setTimeout(() => {
+                                reconnectTimer = undefined;
+                                connect();
+                            }, 2000);
+                        }
+                        
+                        connect();
                     })();
                 <\/script>
             ` : "";
@@ -5866,10 +7217,13 @@ function Cors(options = {}) {
   };
   const opts = { ...defaults2, ...options };
   const corsMiddleware = async function CorsMiddleware(ctx, next) {
-    const headers = new Headers();
+    const headers = {};
     const origin = ctx.headers.get("origin");
-    const set = (k, v) => headers.set(k, v);
-    const append = (k, v) => headers.append(k, v);
+    const set = (k, v) => headers[k] = v;
+    const append = (k, v) => {
+      const current = headers[k];
+      headers[k] = current ? current + "," + v : v;
+    };
     if (origin === "null" && opts.origin !== "null") {
       return next();
     }
@@ -5928,10 +7282,10 @@ function Cors(options = {}) {
     }
     const response = await next();
     if (response instanceof Response) {
-      const headerEntries = Object.entries(headers);
-      for (let i = 0; i < headerEntries.length; i++) {
-        const [key, value] = headerEntries[i];
-        response.headers.set(key, value);
+      const keys = Object.keys(headers);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        response.headers.set(key, headers[key]);
       }
     }
     return response;