shokupan 0.7.0 → 0.10.0

package/dist/index.js

@@ -1,21 +1,59 @@
+import { nanoid } from "nanoid";
 import { readFile } from "node:fs/promises";
+import { inspect } from "node:util";
 import { trace, SpanKind, SpanStatusCode, context } from "@opentelemetry/api";
+import { dump } from "js-yaml";
 import { AsyncLocalStorage } from "node:async_hooks";
+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 * as os from "node:os";
 import os__default from "node:os";
-import { OAuth2Client, Okta, Auth0, Apple, MicrosoftEntraId, Google, GitHub, generateState, generateCodeVerifier } from "arctic";
-import * as jose from "jose";
+import { dirname, join as join$1 } from "node:path";
+import { fileURLToPath } 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 { OpenAPIAnalyzer } from "./analyzer-Ce_7JxZh.js";
+import { monitorEventLoopDelay } from "node:perf_hooks";
+import { readFileSync } from "node:fs";
+import { OpenAPIAnalyzer } from "./analyzer-BqIe1p0R.js";
 import * as zlib from "node:zlib";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import { randomUUID, createHmac } from "crypto";
 import { EventEmitter } from "events";
+const HTTP_STATUS = {
+  // 2xx Success
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  // 3xx Redirection
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  // 4xx Client Errors
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  // 5xx Server Errors
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
 const VALID_HTTP_STATUSES = /* @__PURE__ */ new Set([
   100,
   101,
@@ -145,6 +183,40 @@ class ShokupanResponse {
     return this._headers !== null;
   }
 }
+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 $isRouter = /* @__PURE__ */ Symbol.for("Shokupan.router");
+const $parent = /* @__PURE__ */ Symbol.for("Shokupan.parent");
+const $childRouters = /* @__PURE__ */ Symbol.for("Shokupan.child-routers");
+const $childControllers = /* @__PURE__ */ Symbol.for("Shokupan.child-controllers");
+const $mountPath = /* @__PURE__ */ Symbol.for("Shokupan.mount-path");
+const $dispatch = /* @__PURE__ */ Symbol.for("Shokupan.dispatch");
+const $routes = /* @__PURE__ */ Symbol.for("Shokupan.routes");
+const $routeSpec = /* @__PURE__ */ Symbol.for("Shokupan.routeSpec");
+const $url = /* @__PURE__ */ Symbol.for("Shokupan.ctx.url");
+const $requestId = /* @__PURE__ */ Symbol.for("Shokupan.ctx.requestId");
+const $debug = /* @__PURE__ */ Symbol.for("Shokupan.ctx.debug");
+const $finalResponse = /* @__PURE__ */ Symbol.for("Shokupan.ctx.finalResponse");
+const $rawBody = /* @__PURE__ */ Symbol.for("Shokupan.ctx.rawBody");
+const $cachedBody = /* @__PURE__ */ Symbol.for("Shokupan.ctx.cachedBody");
+const $bodyType = /* @__PURE__ */ Symbol.for("Shokupan.ctx.bodyType");
+const $bodyParsed = /* @__PURE__ */ Symbol.for("Shokupan.ctx.bodyParsed");
+const $bodyParseError = /* @__PURE__ */ Symbol.for("Shokupan.ctx.bodyParseError");
+const $routeMatched = /* @__PURE__ */ Symbol.for("Shokupan.ctx.routeMatched");
+const $cachedHostname = /* @__PURE__ */ Symbol.for("Shokupan.ctx.cachedHostname");
+const $cachedProtocol = /* @__PURE__ */ Symbol.for("Shokupan.ctx.cachedProtocol");
+const $cachedHost = /* @__PURE__ */ Symbol.for("Shokupan.ctx.cachedHost");
+const $cachedOrigin = /* @__PURE__ */ Symbol.for("Shokupan.ctx.cachedOrigin");
+const $cachedQuery = /* @__PURE__ */ Symbol.for("Shokupan.ctx.cachedQuery");
+const $ws = /* @__PURE__ */ Symbol.for("Shokupan.ctx.ws");
+const $socket = /* @__PURE__ */ Symbol.for("Shokupan.ctx.socket");
+const $io = /* @__PURE__ */ Symbol.for("Shokupan.ctx.io");
 function isValidCookieDomain(domain, currentHost) {
   const hostWithoutPort = currentHost.split(":")[0];
   if (domain === hostWithoutPort) return true;
@@ -182,23 +254,41 @@ class ShokupanContext {
   state;
   handlerStack = [];
   response;
-  _debug;
-  _finalResponse;
-  _rawBody;
+  [$debug];
+  [$finalResponse];
+  [$rawBody];
   // Raw body for compression optimization
   // Body caching to avoid double parsing
-  _url;
-  _cachedBody;
-  _bodyType;
-  _bodyParsed = false;
-  _bodyParseError;
-  _routeMatched = false;
+  [$url];
+  [$cachedBody];
+  [$bodyType];
+  [$bodyParsed] = false;
+  [$bodyParseError];
+  [$routeMatched] = false;
   // Cached URL properties to avoid repeated parsing
-  _cachedHostname;
-  _cachedProtocol;
-  _cachedHost;
-  _cachedOrigin;
-  _cachedQuery;
+  [$cachedHostname];
+  [$cachedProtocol];
+  [$cachedHost];
+  [$cachedOrigin];
+  [$cachedQuery];
+  disconnectCallbacks = [];
+  /**
+   * Registers a callback to be executed when the associated WebSocket disconnects.
+   * This is only applicable for requests that are part of a WebSocket interaction or upgrade.
+   */
+  onSocketDisconnect(callback) {
+    this.disconnectCallbacks.push(callback);
+  }
+  /**
+   * @internal
+   * Retrieves registered disconnect callbacks for execution.
+   */
+  getDisconnectCallbacks() {
+    return this.disconnectCallbacks;
+  }
+  [$ws];
+  [$socket];
+  [$io];
   /**
    * JSX Rendering Function
    */
@@ -206,12 +296,30 @@ class ShokupanContext {
   setRenderer(renderer) {
     this.renderer = renderer;
   }
+  [$requestId];
+  get requestId() {
+    return this[$requestId] ??= this.app?.applicationConfig?.idGenerator?.() ?? nanoid();
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    const innerString = inspect({
+      method: this.request.method,
+      url: this.request.url,
+      requestHeaders: new Map(this.request.headers),
+      sessionId: this.sessionID,
+      state: this.state,
+      params: this.params,
+      response: this[$finalResponse]?.body,
+      responseHeaders: new Map(this[$finalResponse]?.headers),
+      handlerStack: this.handlerStack.map((h) => h.name === "anonymous" ? h.file + ":" + h.line : h.name)
+    }, { depth: null, colors: true, numericSeparator: true, customInspect: true });
+    return "Context(" + this.requestId + ") {" + innerString.slice(1, -2) + ",\n  ...others\n}";
+  }
   get url() {
-    if (!this._url) {
+    if (!this[$url]) {
       const urlString = this.request.url || "http://localhost/";
-      this._url = new URL(urlString);
+      this[$url] = new URL(urlString);
     }
-    return this._url;
+    return this[$url];
   }
   /**
    * Base request
@@ -229,7 +337,7 @@ class ShokupanContext {
    * Request path
    */
   get path() {
-    if (this._url) return this._url.pathname;
+    if (this[$url]) return this[$url].pathname;
     const url = this.request.url;
     let queryIndex = url.indexOf("?");
     const end = queryIndex === -1 ? url.length : queryIndex;
@@ -254,13 +362,11 @@ class ShokupanContext {
    * Request query params
    */
   get query() {
-    if (this._cachedQuery) return this._cachedQuery;
+    if (this[$cachedQuery]) return this[$cachedQuery];
     const q = /* @__PURE__ */ Object.create(null);
     const blocklist = ["__proto__", "constructor", "prototype"];
-    const entries = Object.entries(this.url.searchParams);
-    for (let i = 0; i < entries.length; i++) {
-      const [key, value] = entries[i];
-      if (blocklist.includes(key)) continue;
+    this.url.searchParams.forEach((value, key) => {
+      if (blocklist.includes(key)) return;
       if (Object.prototype.hasOwnProperty.call(q, key)) {
         if (Array.isArray(q[key])) {
           q[key].push(value);
@@ -270,8 +376,8 @@ class ShokupanContext {
       } else {
         q[key] = value;
       }
-    }
-    this._cachedQuery = q;
+    });
+    this[$cachedQuery] = q;
     return q;
   }
   /**
@@ -284,19 +390,19 @@ class ShokupanContext {
    * Request hostname (e.g. "localhost")
    */
   get hostname() {
-    return this._cachedHostname ??= this.url.hostname;
+    return this[$cachedHostname] ??= this.url.hostname;
   }
   /**
    * Request host (e.g. "localhost:3000")
    */
   get host() {
-    return this._cachedHost ??= this.url.host;
+    return this[$cachedHost] ??= this.url.host;
   }
   /**
    * Request protocol (e.g. "http:", "https:")
    */
   get protocol() {
-    return this._cachedProtocol ??= this.url.protocol;
+    return this[$cachedProtocol] ??= this.url.protocol;
   }
   /**
    * Whether request is secure (https)
@@ -308,7 +414,7 @@ class ShokupanContext {
    * Request origin (e.g. "http://localhost:3000")
    */
   get origin() {
-    return this._cachedOrigin ??= this.url.origin;
+    return this[$cachedOrigin] ??= this.url.origin;
   }
   /**
    * Request headers
@@ -329,6 +435,24 @@ class ShokupanContext {
   get res() {
     return this.response;
   }
+  /**
+   * Raw WebSocket connection
+   */
+  get ws() {
+    return this[$ws];
+  }
+  /**
+   * Socket.io socket
+   */
+  get socket() {
+    return this[$socket];
+  }
+  /**
+   * Socket.io server
+   */
+  get io() {
+    return this[$io];
+  }
   /**
    * Helper to set a header on the response
    * @param key Header key
@@ -338,6 +462,20 @@ class ShokupanContext {
     this.response.set(key, value);
     return this;
   }
+  isUpgraded = false;
+  /**
+   * Upgrades the request to a WebSocket connection.
+   * @param options Upgrade options
+   * @returns true if upgraded, false otherwise
+   */
+  upgrade(options) {
+    if (!this.server) return false;
+    const success = this.server.upgrade(this.req, options);
+    if (success) {
+      this.isUpgraded = true;
+    }
+    return success;
+  }
   /**
    * Set a cookie
    * @param name Cookie name
@@ -415,18 +553,18 @@ class ShokupanContext {
    * The body is only parsed once and cached for subsequent reads.
    */
   async body() {
-    if (this._bodyParseError) {
-      throw this._bodyParseError;
+    if (this[$bodyParseError]) {
+      throw this[$bodyParseError];
     }
-    if (this._bodyParsed) {
-      return this._cachedBody;
+    if (this[$bodyParsed]) {
+      return this[$cachedBody];
     }
     const contentType = this.request.headers.get("content-type") || "";
     if (contentType.includes("application/json") || contentType.includes("+json")) {
       const parserType = this.app?.applicationConfig?.jsonParser || "native";
       if (parserType === "native") {
         try {
-          this._cachedBody = await this.request.json();
+          this[$cachedBody] = await this.request.json();
         } catch (e) {
           throw e;
         }
@@ -434,18 +572,18 @@ class ShokupanContext {
         const rawText = await this.request.text();
         const { getJSONParser } = await import("./json-parser-B3dnQmCC.js");
         const parser = getJSONParser(parserType);
-        this._cachedBody = parser(rawText);
+        this[$cachedBody] = parser(rawText);
       }
-      this._bodyType = "json";
+      this[$bodyType] = "json";
     } else if (contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded")) {
-      this._cachedBody = await this.request.formData();
-      this._bodyType = "formData";
+      this[$cachedBody] = await this.request.formData();
+      this[$bodyType] = "formData";
     } else {
-      this._cachedBody = await this.request.text();
-      this._bodyType = "text";
+      this[$cachedBody] = await this.request.text();
+      this[$bodyType] = "text";
     }
-    this._bodyParsed = true;
-    return this._cachedBody;
+    this[$bodyParsed] = true;
+    return this[$cachedBody];
   }
   /**
    * Pre-parse the request body before handler execution.
@@ -453,7 +591,7 @@ class ShokupanContext {
    * Errors are deferred until the body is actually accessed in the handler.
    */
   async parseBody() {
-    if (this._bodyParsed) {
+    if (this[$bodyParsed]) {
       return;
     }
     if (this.request.method === "GET" || this.request.method === "HEAD") {
@@ -462,7 +600,7 @@ class ShokupanContext {
     try {
       await this.body();
     } catch (error) {
-      this._bodyParseError = error;
+      this[$bodyParseError] = error;
     }
   }
   /**
@@ -512,116 +650,129 @@ class ShokupanContext {
       throw new Error(`Invalid HTTP status code: ${status}`);
     }
     if (typeof body === "string" || body instanceof ArrayBuffer || body instanceof Uint8Array) {
-      this._rawBody = body;
+      this[$rawBody] = body;
+    }
+    return this[$finalResponse] ??= new Response(body, { status, headers });
+  }
+  /**
+   * Emit an event to the client (WebSocket only)
+   * @param event Event name
+   * @param data Event data (Must be JSON serializable)
+   */
+  emit(event, data) {
+    if (this[$ws]) {
+      this[$ws].send(JSON.stringify({ event, data }));
+    } else if (this[$socket]) {
+      this[$socket].emit(event, data);
     }
-    this._finalResponse = new Response(body, { status, headers });
-    return this._finalResponse;
   }
   /**
    * Respond with a JSON object
    */
-  json(data, status, headers) {
+  async json(data, status, headers) {
     const finalStatus = status ?? this.response.status ?? 200;
     if (!VALID_HTTP_STATUSES.has(finalStatus)) {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
-    const jsonString = JSON.stringify(data);
-    this._rawBody = jsonString;
+    const jsonString = JSON.stringify(data instanceof Promise ? await data : data);
+    this[$rawBody] = jsonString;
     if (!headers && !this.response.hasPopulatedHeaders) {
-      this._finalResponse = new Response(jsonString, {
+      this[$finalResponse] = new Response(jsonString, {
         status: finalStatus,
         headers: { "content-type": "application/json" }
       });
-      return this._finalResponse;
+      return this[$finalResponse];
     }
     const finalHeaders = this.mergeHeaders(headers);
     finalHeaders.set("content-type", "application/json");
-    this._finalResponse = new Response(jsonString, { status: finalStatus, headers: finalHeaders });
-    return this._finalResponse;
+    this[$finalResponse] = new Response(jsonString, { status: finalStatus, headers: finalHeaders });
+    return this[$finalResponse];
   }
   /**
    * Respond with a text string
    */
-  text(data, status, headers) {
+  async text(data, status, headers) {
     const finalStatus = status ?? this.response.status ?? 200;
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(finalStatus)) {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
-    this._rawBody = data;
+    this[$rawBody] = data instanceof Promise ? await data : data;
     if (!headers && !this.response.hasPopulatedHeaders) {
-      this._finalResponse = new Response(data, {
+      this[$finalResponse] = new Response(this[$rawBody], {
         status: finalStatus,
         headers: { "content-type": "text/plain; charset=utf-8" }
       });
-      return this._finalResponse;
+      return this[$finalResponse];
     }
     const finalHeaders = this.mergeHeaders(headers);
     finalHeaders.set("content-type", "text/plain; charset=utf-8");
-    this._finalResponse = new Response(data, { status: finalStatus, headers: finalHeaders });
-    return this._finalResponse;
+    this[$finalResponse] = new Response(this[$rawBody], { status: finalStatus, headers: finalHeaders });
+    return this[$finalResponse];
   }
   /**
    * Respond with HTML content
    */
-  html(html, status, headers) {
+  async html(html, status, headers) {
     const finalStatus = status ?? this.response.status ?? 200;
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(finalStatus)) {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
     const finalHeaders = this.mergeHeaders(headers);
     finalHeaders.set("content-type", "text/html; charset=utf-8");
-    this._rawBody = html;
-    this._finalResponse = new Response(html, { status: finalStatus, headers: finalHeaders });
-    return this._finalResponse;
+    this[$rawBody] = html instanceof Promise ? await html : html;
+    this[$finalResponse] = new Response(this[$rawBody], { status: finalStatus, headers: finalHeaders });
+    return this[$finalResponse];
   }
   /**
    * Respond with a redirect
    */
-  redirect(url, status = 302) {
+  async redirect(url, status = 302) {
     if (this.app.applicationConfig.validateStatusCodes && !VALID_REDIRECT_STATUSES.has(status)) {
       throw new Error(`Invalid redirect status code: ${status}`);
     }
-    const headers = this.mergeHeaders();
-    headers.set("Location", url);
-    this._finalResponse = new Response(null, { status, headers });
-    return this._finalResponse;
+    const finalHeaders = this.mergeHeaders();
+    finalHeaders.set("Location", url instanceof Promise ? await url : url);
+    this[$finalResponse] = new Response(null, { status, headers: finalHeaders });
+    return this[$finalResponse];
   }
   /**
    * Respond with a status code
    * DOES NOT CHAIN!
    */
-  status(status) {
+  async status(statusCode) {
+    const status = statusCode instanceof Promise ? await statusCode : statusCode;
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(status)) {
       throw new Error(`Invalid HTTP status code: ${status}`);
     }
-    const headers = this.mergeHeaders();
-    this._finalResponse = new Response(null, { status, headers });
-    return this._finalResponse;
+    const finalHeaders = this.mergeHeaders();
+    this[$finalResponse] = new Response(null, { status, headers: finalHeaders });
+    return this[$finalResponse];
   }
   /**
    * Respond with a file
    */
   async file(path, fileOptions, responseOptions) {
-    const headers = this.mergeHeaders(responseOptions?.headers);
+    const finalHeaders = this.mergeHeaders(responseOptions?.headers);
     const status = responseOptions?.status ?? this.response.status;
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(status)) {
       throw new Error(`Invalid HTTP status code: ${status}`);
     }
     if (typeof Bun !== "undefined") {
-      this._finalResponse = new Response(Bun.file(path, fileOptions), { status, headers });
-      return this._finalResponse;
+      this[$finalResponse] = new Response(Bun.file(path, fileOptions), { status, headers: finalHeaders });
+      return this[$finalResponse];
     } else {
       const fileBuffer = await readFile(path);
       if (fileOptions?.type) {
-        headers.set("content-type", fileOptions.type);
+        finalHeaders.set("content-type", fileOptions.type);
       }
-      this._finalResponse = new Response(fileBuffer, { status, headers });
-      return this._finalResponse;
+      this[$finalResponse] = new Response(fileBuffer, { status, headers: finalHeaders });
+      return this[$finalResponse];
     }
   }
   /**
    * Render a JSX element
    * @param element JSX Element
+   * @param args JSX Element Args/Props
    * @param status HTTP Status
    * @param headers HTTP Headers
    */
@@ -652,10 +803,10 @@ const compose = (middleware) => {
         return next ? next() : Promise.resolve();
       }
       const fn = middleware[i];
-      if (!context2._debug) {
+      if (!context2[$debug]) {
         return fn(context2, () => runner(i + 1));
       }
-      const debug = context2._debug;
+      const debug = context2[$debug];
       const debugId = fn._debugId || fn.name || "anonymous";
       const previousNode = debug.getCurrentNode();
       debug.trackEdge(previousNode, debugId);
@@ -675,29 +826,6 @@ const compose = (middleware) => {
     return runner(0);
   };
 };
-const tracer = trace.getTracer("shokupan.middleware");
-function traceHandler(fn, name) {
-  return async function(...args) {
-    return tracer.startActiveSpan(`route handler - ${name}`, {
-      kind: SpanKind.INTERNAL,
-      attributes: {
-        "http.route": name,
-        "component": "shokupan.route"
-      }
-    }, async (span) => {
-      try {
-        const result = await fn.apply(this, args);
-        return result;
-      } catch (err) {
-        span.recordException(err);
-        span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
-        throw err;
-      } finally {
-        span.end();
-      }
-    });
-  };
-}
 function isObject(item) {
   return item && typeof item === "object" && !Array.isArray(item);
 }
@@ -731,21 +859,6 @@ function deepMerge(target, ...sources) {
   }
   return deepMerge(target, ...sources);
 }
-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 $routeArgs = /* @__PURE__ */ Symbol("Shokupan.routeArgs");
-const $controllerPath = /* @__PURE__ */ Symbol("Shokupan.controllerPath");
-const $middleware = /* @__PURE__ */ Symbol("Shokupan.middleware");
-const $isRouter = /* @__PURE__ */ Symbol.for("Shokupan.router");
-const $parent = /* @__PURE__ */ Symbol.for("Shokupan.parent");
-const $childRouters = /* @__PURE__ */ Symbol.for("Shokupan.child-routers");
-const $childControllers = /* @__PURE__ */ Symbol.for("Shokupan.child-controllers");
-const $mountPath = /* @__PURE__ */ Symbol.for("Shokupan.mount-path");
-const $dispatch = /* @__PURE__ */ Symbol.for("Shokupan.dispatch");
-const $routes = /* @__PURE__ */ Symbol.for("Shokupan.routes");
-const $routeSpec = /* @__PURE__ */ Symbol.for("Shokupan.routeSpec");
 const REGEX_PATTERNS = {
   QUERY_INT: /parseInt\(ctx\.query\.(\w+)\)/g,
   QUERY_FLOAT: /parseFloat\(ctx\.query\.(\w+)\)/g,
@@ -885,24 +998,34 @@ function analyzeHandler(handler) {
   }
   return { inferredSpec };
 }
-async function getAstRoutes(applications) {
+async function getAstRoutes$1(applications) {
   const astRoutes = [];
-  const getExpandedRoutes = (app, prefix = "", seen = /* @__PURE__ */ new Set()) => {
+  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 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+      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);
       }
-      expanded.push({
+      const expandedRoute = {
         ...route,
         path: joined || "/"
-      });
+      };
+      if (sourceOverride) {
+        expandedRoute.sourceContext = sourceOverride;
+      }
+      expanded.push(expandedRoute);
     }
     if (app.mounted) {
       for (const mount of app.mounted) {
@@ -910,7 +1033,23 @@ async function getAstRoutes(applications) {
         if (targetApp) {
           const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
           const mountPrefix = mount.prefix.startsWith("/") ? mount.prefix : "/" + mount.prefix;
-          expanded.push(...getExpandedRoutes(targetApp, cleanPrefix + mountPrefix, newSeen));
+          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));
         }
       }
     }
@@ -938,13 +1077,13 @@ async function generateOpenApi(rootRouter, options = {}) {
   const defaultTagName = options.defaultTag || "Application";
   let astRoutes = [];
   try {
-    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-Ce_7JxZh.js");
+    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-BqIe1p0R.js");
     const analyzer = new OpenAPIAnalyzer2(process.cwd());
     const { applications } = await analyzer.analyze();
-    astRoutes = await getAstRoutes(applications);
+    astRoutes = await getAstRoutes$1(applications);
   } catch (e) {
   }
-  const collect = (router, prefix = "", currentGroup = defaultTagGroup, defaultTag = defaultTagName) => {
+  const collect = (router, prefix = "", currentGroup = defaultTagGroup, defaultTag = defaultTagName, inheritedMiddleware = []) => {
     let group = currentGroup;
     let tag = defaultTag;
     if (router.config?.group) group = router.config.group;
@@ -961,21 +1100,33 @@ async function generateOpenApi(rootRouter, options = {}) {
       }
     }
     if (!tagGroups.has(group)) tagGroups.set(group, /* @__PURE__ */ new Set());
+    const routerMiddleware = router.middleware || [];
     const routes = router[$routes] || [];
     for (const route of routes) {
+      if (!["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"].includes(route.method.toUpperCase())) {
+        continue;
+      }
       const routeGroup = route.group || group;
       const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
       const cleanSubPath = route.path.startsWith("/") ? route.path : "/" + route.path;
       let fullPath = cleanPrefix + cleanSubPath || "/";
-      fullPath = fullPath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
       if (fullPath.length > 1 && fullPath.endsWith("/")) {
         fullPath = fullPath.slice(0, -1);
       }
+      fullPath = fullPath.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
       if (!paths[fullPath]) paths[fullPath] = {};
       const operation = {
         responses: { "200": { description: "Successful response" } },
         tags: [tag]
       };
+      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
+        }));
+      }
       if (route.guards) {
         for (const guard of route.guards) {
           if (guard.spec) {
@@ -1013,6 +1164,23 @@ async function generateOpenApi(rootRouter, options = {}) {
         if (astMatch.description) operation.description = astMatch.description;
         if (astMatch.tags) operation.tags = astMatch.tags;
         if (astMatch.operationId) operation.operationId = astMatch.operationId;
+        if (astMatch.sourceContext) {
+          const sc = astMatch.sourceContext;
+          operation["x-source-info"] = {
+            file: sc.file,
+            line: sc.startLine,
+            snippet: sc.snippet || astMatch.handlerSource,
+            // Fallback
+            offset: sc.snippetStartLine || sc.startLine,
+            highlightLines: [sc.startLine, sc.endLine],
+            highlights: sc.highlights
+          };
+          operation["x-shokupan-source"] = {
+            file: sc.file,
+            line: sc.startLine,
+            code: sc.snippet || astMatch.handlerSource || ""
+          };
+        }
         if (astMatch.requestTypes?.body) {
           operation.requestBody = {
             content: { "application/json": { schema: astMatch.requestTypes.body } }
@@ -1024,10 +1192,12 @@ async function generateOpenApi(rootRouter, options = {}) {
             content: { "application/json": { schema: astMatch.responseSchema } }
           };
         } else if (astMatch.responseType) {
-          const contentType = astMatch.responseType === "string" ? "text/plain" : "application/json";
+          let contentType = "application/json";
+          if (astMatch.responseType === "string") contentType = "text/plain";
+          else if (astMatch.responseType === "html") contentType = "text/html";
           operation.responses["200"] = {
             description: "Successful response",
-            content: { [contentType]: { schema: { type: astMatch.responseType } } }
+            content: { [contentType]: { schema: { type: "string" } } }
           };
         }
         const params = [];
@@ -1039,6 +1209,26 @@ async function generateOpenApi(rootRouter, options = {}) {
         if (params.length > 0) {
           operation.parameters = params;
         }
+      } else {
+        const runtimeSource = (route.handler.originalHandler || route.handler).toString();
+        let file;
+        let line;
+        if (route.metadata?.file) {
+          file = route.metadata.file;
+          line = route.metadata.line || 1;
+        }
+        operation["x-source-info"] = {
+          snippet: runtimeSource,
+          isRuntime: true,
+          ...file ? { file, line: line || 1 } : {}
+        };
+        if (file) {
+          operation["x-shokupan-source"] = {
+            file,
+            line: line || 1,
+            code: runtimeSource
+          };
+        }
       }
       if (route.keys.length > 0) {
         const pathParams = route.keys.map((key) => ({
@@ -1108,7 +1298,7 @@ async function generateOpenApi(rootRouter, options = {}) {
       const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
       const cleanMount = mountPath.startsWith("/") ? mountPath : "/" + mountPath;
       const nextPrefix = cleanPrefix + cleanMount || "/";
-      collect(child, nextPrefix, group, tag);
+      collect(child, nextPrefix, group, tag, [...inheritedMiddleware, ...routerMiddleware]);
     }
   };
   collect(rootRouter);
@@ -1132,7 +1322,36 @@ class RequestContextStore {
   span;
 }
 const asyncContext = new AsyncLocalStorage();
-const eta$1 = new Eta();
+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 eta = new Eta();
 function serveStatic(config, prefix) {
   const rootPath = resolve(config.root || ".");
   const normalizedPrefix = prefix.endsWith("/") && prefix !== "/" ? prefix.slice(0, -1) : prefix;
@@ -1231,7 +1450,7 @@ function serveStatic(config, prefix) {
         if (config.listDirectory) {
           try {
             const files = await readdir(requestPath);
-            const listing = eta$1.renderString(`
+            const listing = eta.renderString(`
                                 <!DOCTYPE html>
                                 <html>
                                 <head>
@@ -1271,7 +1490,7 @@ function serveStatic(config, prefix) {
     if (typeof Bun !== "undefined") {
       response = new Response(Bun.file(finalPath));
     } else {
-      const fileBuffer = await readFile$1(finalPath);
+      const fileBuffer = await readFile$1(finalPath, { encoding: "binary" });
       response = new Response(fileBuffer);
     }
     if (config.hooks?.onResponse) {
@@ -1284,69 +1503,6 @@ function serveStatic(config, prefix) {
   serveStaticMiddleware.pluginName = "ServeStatic";
   return serveStaticMiddleware;
 }
-let db;
-let dbPromise = null;
-let RecordId;
-async function ensureDb() {
-  if (db) return db;
-  if (dbPromise) return dbPromise;
-  dbPromise = (async () => {
-    try {
-      const { createNodeEngines } = await import("@surrealdb/node");
-      const surreal = await import("surrealdb");
-      const Surreal = surreal.Surreal;
-      RecordId = surreal.RecordId;
-      const engine = process.env["SHOKUPAN_DB_ENGINE"] === "memory" ? "mem://" : "rocksdb://database";
-      const _db = new Surreal({
-        engines: createNodeEngines()
-      });
-      await _db.connect(engine, { namespace: "vendor", database: "shokupan" });
-      await _db.query(`
-            DEFINE TABLE OVERWRITE failed_requests SCHEMALESS COMMENT "Created by Shokupan";
-            DEFINE TABLE OVERWRITE sessions SCHEMALESS COMMENT "Created by Shokupan";
-            DEFINE TABLE OVERWRITE users SCHEMALESS COMMENT "Created by Shokupan";
-            DEFINE TABLE OVERWRITE idempotency_keys SCHEMALESS COMMENT "Created by Shokupan";
-            DEFINE TABLE OVERWRITE middleware_tracking SCHEMALESS COMMENT "Created by Shokupan";
-            DEFINE TABLE OVERWRITE requests SCHEMALESS COMMENT "Created by Shokupan";
-        `);
-      db = _db;
-      return db;
-    } catch (e) {
-      dbPromise = null;
-      if (e.code === "ERR_MODULE_NOT_FOUND" || e.message.includes("Cannot find module")) {
-        throw new Error("SurrealDB dependencies not found. To use the datastore, please install 'surrealdb' and '@surrealdb/node'.");
-      }
-      throw e;
-    }
-  })();
-  return dbPromise;
-}
-const datastore = {
-  async get(store, key) {
-    await ensureDb();
-    return db.select(new RecordId(store, key));
-  },
-  async set(store, key, value) {
-    await ensureDb();
-    return db.create(new RecordId(store, key)).content(value);
-  },
-  async query(query, vars) {
-    await ensureDb();
-    try {
-      const r = await db.query(query, vars);
-      return Array.isArray(r) ? r : r?.collect ? await r.collect() : r;
-    } catch (e) {
-      console.error("DS ERROR:", e);
-      throw e;
-    }
-  },
-  get ready() {
-    return ensureDb().then(() => void 0);
-  }
-};
-process.on("exit", async () => {
-  if (db) await db.close();
-});
 class Container {
   static services = /* @__PURE__ */ new Map();
   static register(target, instance) {
@@ -1380,6 +1536,29 @@ function Inject(token) {
     });
   };
 }
+const tracer = trace.getTracer("shokupan.middleware");
+function traceHandler(fn, name) {
+  return async function(...args) {
+    return tracer.startActiveSpan(`route handler - ${name}`, {
+      kind: SpanKind.INTERNAL,
+      attributes: {
+        "http.route": name,
+        "component": "shokupan.route"
+      }
+    }, async (span) => {
+      try {
+        const result = await fn.apply(this, args);
+        return result;
+      } catch (err) {
+        span.recordException(err);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+        throw err;
+      } finally {
+        span.end();
+      }
+    });
+  };
+}
 class ShokupanRequestBase {
   method;
   url;
@@ -1417,8 +1596,10 @@ function getCallerInfo(skipFrames = 1) {
       if (!l.includes(":")) continue;
       if (l.includes("node_modules")) continue;
       if (l.includes("bun:main")) continue;
+      if (l.includes("bun:wrap")) continue;
       if (l.includes("src/util/stack.ts")) continue;
       if (l.includes("src/router.ts")) continue;
+      if (l.includes("src/util/decorators.ts")) continue;
       if (l.includes("src/shokupan.ts")) continue;
       found++;
       if (found >= skipFrames) {
@@ -1561,6 +1742,9 @@ class ShokupanRouter {
   [$parent] = null;
   [$childRouters] = [];
   [$childControllers] = [];
+  get db() {
+    return this.root?.db;
+  }
   hookCache = /* @__PURE__ */ new Map();
   hooksInitialized = false;
   middleware = [];
@@ -1576,6 +1760,15 @@ class ShokupanRouter {
   metadata;
   // Metadata for the router itself
   currentGuards = [];
+  eventHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Registers middleware for this router.
+   * Middleware will run for all routes matched by this router.
+   */
+  use(middleware) {
+    this.middleware.push(middleware);
+    return this;
+  }
   // Registry Accessor
   getComponentRegistry() {
     const controllerRoutesMap = /* @__PURE__ */ new Map();
@@ -1636,6 +1829,42 @@ class ShokupanRouter {
   isRouterInstance(target) {
     return typeof target === "object" && target !== null && $isRouter in target;
   }
+  /**
+   * Registers an event handler for WebSocket.
+   */
+  event(name, handler) {
+    const info = getCallerInfo();
+    handler.source = { file: info.file, line: info.line };
+    if (this.eventHandlers.has(name)) {
+      const err = new EventError(`Event handler \`${name}\` already exists.`);
+      console.warn(err);
+      const handlers = this.eventHandlers.get(name);
+      handlers.push(handler);
+      this.eventHandlers.set(name, handlers);
+    } else {
+      this.eventHandlers.set(name, [handler]);
+    }
+    return this;
+  }
+  /**
+   * Finds an event handler(s) by name.
+   */
+  findEvent(name) {
+    if (this.eventHandlers.has(name)) {
+      return this.eventHandlers.get(name);
+    }
+    for (const child of this[$childRouters]) {
+      const handler = child.findEvent(name);
+      if (handler) return handler;
+    }
+    return null;
+  }
+  /**
+   * Returns all registered event handlers.
+   */
+  getEventHandlers() {
+    return this.eventHandlers;
+  }
   /**
    * Mounts a controller instance to a path prefix.
    * 
@@ -1736,7 +1965,7 @@ class ShokupanRouter {
     });
     const ctx = new ShokupanContext(req);
     let result = null;
-    let status = 200;
+    let status = HTTP_STATUS.OK;
     const headers = {};
     const match = this.find(req.method, ctx.path);
     if (match) {
@@ -1745,12 +1974,12 @@ class ShokupanRouter {
         result = await match.handler(ctx);
       } catch (err) {
         console.error(err);
-        status = err.status || err.statusCode || 500;
+        status = getErrorStatus(err);
         result = { error: err.message || "Internal Server Error" };
         if (err.errors) result.errors = err.errors;
       }
     } else {
-      status = 404;
+      status = HTTP_STATUS.NOT_FOUND;
       result = "Not Found";
     }
     if (result instanceof Response) {
@@ -1779,7 +2008,7 @@ class ShokupanRouter {
     const originalHandler = handler;
     const wrapped = async (ctx) => {
       await this.runHooks("onRequestStart", ctx);
-      const debug = ctx._debug;
+      const debug = ctx[$debug];
       let debugId;
       let previousNode;
       if (debug) {
@@ -1869,6 +2098,7 @@ class ShokupanRouter {
     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];
@@ -1878,10 +2108,12 @@ class ShokupanRouter {
       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];
@@ -2011,7 +2243,54 @@ class ShokupanRouter {
         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 });
+        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) {
@@ -2080,7 +2359,7 @@ class ShokupanRouter {
    * @param arg.renderer - JSX renderer for the route
    * @param arg.controller - Controller for the route
    */
-  add({ method, path, spec, handler, regex: customRegex, group, requestTimeout, renderer, controller }) {
+  add({ method, path, spec, handler, regex: customRegex, group, requestTimeout, renderer, controller, metadata, middleware }) {
     const { regex, keys } = customRegex ? { regex: customRegex, keys: [] } : this.parsePath(path);
     if (this.currentGuards.length > 0) {
       spec = spec || {};
@@ -2098,7 +2377,13 @@ class ShokupanRouter {
         }
       }
     }
-    let wrappedHandler = handler;
+    let wrappedHandler = async (ctx) => {
+      if (ctx.upgrade()) {
+        return void 0;
+      }
+      return handler(ctx);
+    };
+    wrappedHandler.originalHandler = handler.originalHandler || handler;
     const routeGuards = [...this.currentGuards];
     const effectiveTimeout = requestTimeout ?? this.requestTimeout ?? this.rootConfig?.requestTimeout;
     if (effectiveTimeout !== void 0 && effectiveTimeout > 0) {
@@ -2149,7 +2434,7 @@ class ShokupanRouter {
         return innerHandler(ctx);
       };
     }
-    const { file, line } = getCallerInfo();
+    const { file, line } = metadata || getCallerInfo();
     const trackingHandler = wrappedHandler;
     wrappedHandler = async (ctx) => {
       if (!ctx.app?.applicationConfig.enableMiddlewareTracking) {
@@ -2175,9 +2460,13 @@ class ShokupanRouter {
           const config = ctx.app.applicationConfig;
           Promise.resolve().then(async () => {
             try {
+              const db = ctx.app?.db;
+              if (!db) return;
               const timestamp = Date.now();
-              const key = `${timestamp}-${handler.name || "anonymous"}-${Math.random().toString(36).substring(7)}`;
-              await datastore.set("middleware_tracking", key, {
+              await db.upsert(new RecordId("middleware_tracking", {
+                timestamp,
+                name: handler.name || "anonymous"
+              }), {
                 name: handler.name || "anonymous",
                 path: ctx.path,
                 timestamp,
@@ -2193,11 +2482,11 @@ class ShokupanRouter {
               const ttl = config.middlewareTrackingTTL ?? 864e5;
               const maxCapacity = config.middlewareTrackingMaxCapacity ?? 1e4;
               const cutoff = Date.now() - ttl;
-              await datastore.query(`DELETE middleware_tracking WHERE timestamp < ${cutoff}`);
-              const results = await datastore.query("SELECT count() FROM middleware_tracking GROUP ALL");
-              if (results && results[0] && results[0].count > maxCapacity) {
+              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 datastore.query(`DELETE middleware_tracking ORDER BY timestamp ASC LIMIT ${toDelete}`);
+                await db.query(`DELETE middleware_tracking ORDER BY timestamp ASC LIMIT ${toDelete}`);
               }
             } catch (datastoreError) {
               console.error("Failed to store middleware tracking:", datastoreError);
@@ -2227,7 +2516,8 @@ class ShokupanRouter {
         file,
         line
       },
-      controller
+      controller,
+      middleware: middleware || []
     });
     this.trie.insert(method, path, bakedHandler);
     return this;
@@ -2272,7 +2562,7 @@ class ShokupanRouter {
         (l) => l.includes(":") && !l.includes("router.ts") && !l.includes("shokupan.ts") && !l.includes("node_modules") && !l.includes("bun:main")
       );
       if (callerLine) {
-        const match = callerLine.match(/\((.*):(\d+):(\d+)\)/) || callerLine.match(/at (.*):(\d+):(\d+)/);
+        const match = callerLine.match(/\((.{0,1000}):(\d{1,10}):(?:\d{1,10})\)/) || callerLine.match(/at (.{0,1000}):(\d{1,10}):(?:\d{1,10})/);
         if (match) {
           file = match[1];
           line = parseInt(match[2], 10);
@@ -2290,7 +2580,7 @@ class ShokupanRouter {
       }
       return guardHandler(ctx, next);
     };
-    trackedGuard.originalHandler = guardHandler.originalHandler || guardHandler;
+    trackedGuard.originalHandler = guardHandler.originalHandler ?? guardHandler;
     this.currentGuards.push({ handler: trackedGuard, spec });
     return this;
   }
@@ -2356,7 +2646,8 @@ class ShokupanRouter {
       method,
       path,
       spec,
-      handler: finalHandler
+      handler: finalHandler,
+      middleware: handlers.slice(0, handlers.length - 1)
     });
   }
   /**
@@ -2396,16 +2687,16 @@ class ShokupanRouter {
     }
     this.hooksInitialized = true;
   }
-  async runHooks(name, ...args) {
+  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;
+    const debug = ctx?.[$debug];
     if (debug) {
-      await Promise.all(fns.map(async (fn, index) => {
+      return Promise.all(fns.map(async (fn, index) => {
         const hookId = `hook_${name}_${fn.name || index}`;
         const previousNode = debug.getCurrentNode();
         debug.trackEdge(previousNode, hookId);
@@ -2424,7 +2715,7 @@ class ShokupanRouter {
         }
       }));
     } else {
-      await Promise.all(fns.map((fn) => fn(...args)));
+      return Promise.all(fns.map((fn) => fn(...args)));
     }
   }
 }
@@ -2471,45 +2762,160 @@ class SystemCpuMonitor {
     this.currentUsage = total === 0 ? 0 : (1 - idle / total) * 100;
   }
 }
-const defaults = {
-  port: 3e3,
-  hostname: "localhost",
-  development: process.env.NODE_ENV !== "production",
-  enableAsyncLocalStorage: false,
-  reusePort: false
-};
-trace.getTracer("shokupan.application");
-class Shokupan extends ShokupanRouter {
-  applicationConfig = {};
-  openApiSpec;
-  composedMiddleware;
-  cpuMonitor;
-  get logger() {
-    return this.applicationConfig.logger;
+class SurrealDatastore {
+  constructor(db) {
+    this.db = db;
+    process.on("exit", async () => {
+      await this.disconnect();
+    });
   }
-  constructor(applicationConfig = {}) {
-    const config = Object.assign({}, defaults, applicationConfig);
-    const { hooks, ...routerConfig } = config;
-    super({ ...routerConfig, hooks });
-    this[$isApplication] = true;
-    this[$appRoot] = this;
-    this.applicationConfig = config;
-    const { file, line } = getCallerInfo();
-    this.metadata = {
-      file,
-      line,
-      name: "ShokupanApplication"
-    };
+  createSchema() {
+    this.db.query(`
+            DEFINE TABLE OVERWRITE failed_requests SCHEMALESS COMMENT "Created by Shokupan";
+            DEFINE TABLE OVERWRITE sessions SCHEMALESS COMMENT "Created by Shokupan";
+            DEFINE TABLE OVERWRITE users SCHEMALESS COMMENT "Created by Shokupan";
+            DEFINE TABLE OVERWRITE idempotency_keys SCHEMALESS COMMENT "Created by Shokupan";
+            DEFINE TABLE OVERWRITE middleware_tracking SCHEMALESS COMMENT "Created by Shokupan";
+            DEFINE TABLE OVERWRITE requests SCHEMALESS COMMENT "Created by Shokupan";
+            DEFINE TABLE OVERWRITE metrics SCHEMALESS COMMENT "Created by Shokupan";
+        `).collect();
   }
   /**
-   * Adds middleware to the application.
+   * Select a record or contents of a table by its ID.
    */
-  use(middleware) {
-    const { file, line } = getCallerInfo();
-    if (!middleware.metadata) {
-      middleware.metadata = {
-        file,
-        line,
+  async select(id) {
+    return this.db.select(id);
+  }
+  /**
+   * Merge update data into a record by its ID.
+   */
+  async merge(id, data) {
+    return this.db.update(id).merge(data).catch((err) => {
+      if (err.message.includes("This transaction can be retried")) {
+        return this.db.update(id).merge(data);
+      }
+      throw err;
+    });
+  }
+  /**
+   * Create a record by its ID.
+   */
+  async create(id, data) {
+    return this.db.create(id).content(data).catch((err) => {
+      if (err.message.includes("This transaction can be retried")) {
+        return this.db.create(id).content(data);
+      }
+      throw err;
+    });
+  }
+  /**
+   * Upsert a record by its ID.
+   */
+  async upsert(id, data) {
+    return this.db.upsert(id).content(data).catch((err) => {
+      if (err.message.includes("This transaction can be retried")) {
+        return this.db.upsert(id).content(data);
+      }
+      throw err;
+    });
+  }
+  /**
+   * Delete a record by its ID.
+   */
+  async delete(id) {
+    return this.db.delete(id).catch((err) => {
+      if (err.message.includes("This transaction can be retried")) {
+        return this.db.delete(id);
+      }
+      throw err;
+    });
+  }
+  /**
+   * Run a SurrealDB query.
+   */
+  async query(query, vars) {
+    return this.db.query(query, vars).collect().catch((err) => {
+      if (err.message.includes("This transaction can be retried")) {
+        return this.db.query(query, vars).collect();
+      }
+      throw err;
+    });
+  }
+  /**
+   * Create a relationship between two records.
+   */
+  async relate(fromId, edgeId, toId, data) {
+    return this.db.relate(fromId, edgeId, toId, data).catch((err) => {
+      if (err.message.includes("This transaction can be retried")) {
+        return this.db.relate(fromId, edgeId, toId, data);
+      }
+      throw err;
+    });
+  }
+  disconnect() {
+    return this.db.close();
+  }
+}
+const defaults = {
+  port: 3e3,
+  hostname: "localhost",
+  development: process.env.NODE_ENV !== "production",
+  enableAsyncLocalStorage: false,
+  enableHttpBridge: false,
+  reusePort: false
+};
+trace.getTracer("shokupan.application");
+class Shokupan extends ShokupanRouter {
+  applicationConfig = {};
+  openApiSpec;
+  asyncApiSpec;
+  composedMiddleware;
+  cpuMonitor;
+  server;
+  datastore;
+  dbPromise;
+  get db() {
+    return this.datastore;
+  }
+  get logger() {
+    return this.applicationConfig.logger;
+  }
+  constructor(applicationConfig = {}) {
+    const config = Object.assign({}, defaults, applicationConfig);
+    const { hooks, ...routerConfig } = config;
+    super({ ...routerConfig, hooks });
+    this[$isApplication] = true;
+    this[$appRoot] = this;
+    this.applicationConfig = config;
+    const { file, line } = getCallerInfo();
+    this.metadata = {
+      file,
+      line,
+      name: "ShokupanApplication"
+    };
+    this.dbPromise = this.initDatastore();
+  }
+  async initDatastore() {
+    const db = new Surreal({ engines: this.applicationConfig.surreal?.engines ?? (await import("@surrealdb/node")).createNodeEngines() });
+    this.datastore = new SurrealDatastore(db);
+    await db.connect(
+      this.applicationConfig.surreal?.url ?? (process.env.NODE_ENV === "test" ? "mem://" : "surrealkv://database"),
+      this.applicationConfig.surreal?.connectOptions
+    );
+    await db.use({
+      namespace: this.applicationConfig.surreal?.namespace ?? "vendor",
+      database: this.applicationConfig.surreal?.database ?? "shokupan"
+    });
+  }
+  /**
+   * 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
@@ -2579,19 +2985,76 @@ class Shokupan extends ShokupanRouter {
    */
   async listen(port) {
     const finalPort = port ?? this.applicationConfig.port ?? 3e3;
-    if (finalPort < 0 || finalPort > 65535) {
+    if (finalPort < 0 || finalPort > 65535 || finalPort % 1 !== 0) {
       throw new Error("Invalid port number");
     }
     await Promise.all(this.startupHooks.map((hook) => hook()));
     if (this.applicationConfig.enableOpenApiGen) {
       this.openApiSpec = await generateOpenApi(this);
+      this.get("/.well-known/openapi.yaml", (ctx) => {
+        try {
+          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 });
+          return ctx.text("Internal Server Error", 500);
+        }
+      });
+      if (this.applicationConfig.aiPlugin?.enabled !== false) {
+        this.get("/.well-known/ai-plugin.json", async (ctx) => {
+          const config = this.applicationConfig.aiPlugin || {};
+          let pkg = {};
+          try {
+            pkg = await Bun.file("package.json").json();
+          } catch (e) {
+          }
+          const manifest = {
+            schema_version: "v1",
+            name_for_human: config.name_for_human || this.openApiSpec.info.title || pkg.name || "Shokupan App",
+            name_for_model: config.name_for_model || this.openApiSpec.info.title || pkg.name || "Shokupan App",
+            description_for_human: config.description_for_human || this.openApiSpec.info.description || pkg.description || "Shokupan Application",
+            description_for_model: config.description_for_model || this.openApiSpec.info.description || pkg.description || "Shokupan Application",
+            auth: config.auth || { type: "none" },
+            api: config.api || {
+              type: "openapi",
+              url: `${this.applicationConfig.hostname === "localhost" ? "http" : "https"}://${this.applicationConfig.hostname}:${finalPort}/.well-known/openapi.yaml`,
+              is_user_authenticated: false
+            },
+            logo_url: config.logo_url || `${this.applicationConfig.hostname === "localhost" ? "http" : "https"}://${this.applicationConfig.hostname}:${finalPort}/logo.png`,
+            // Placeholder default
+            contact_email: config.contact_email || pkg.author?.email || "support@example.com",
+            legal_info_url: config.legal_info_url || `${this.applicationConfig.hostname === "localhost" ? "http" : "https"}://${this.applicationConfig.hostname}:${finalPort}/legal`
+          };
+          return ctx.json(manifest);
+        });
+      }
+      if (this.applicationConfig.apiCatalog?.enabled !== false) {
+        this.get("/.well-known/api-catalog", (ctx) => {
+          const config = this.applicationConfig.apiCatalog || {};
+          const catalog = {
+            versions: config.versions || [
+              {
+                name: this.openApiSpec.info.version || "v1",
+                url: `${this.applicationConfig.hostname === "localhost" ? "http" : "https"}://${this.applicationConfig.hostname}:${finalPort}/`,
+                spec_url: `${this.applicationConfig.hostname === "localhost" ? "http" : "https"}://${this.applicationConfig.hostname}:${finalPort}/.well-known/openapi.yaml`
+              }
+            ]
+          };
+          return ctx.json(catalog);
+        });
+      }
       await Promise.all(this.specAvailableHooks.map((hook) => hook(this.openApiSpec)));
     }
+    if (this.applicationConfig.enableAsyncApiGen) {
+      const { generateAsyncApi: generateAsyncApi2 } = await Promise.resolve().then(() => generator);
+      this.asyncApiSpec = await generateAsyncApi2(this);
+    }
     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,
@@ -2603,25 +3066,116 @@ class Shokupan extends ShokupanRouter {
         open(ws) {
           ws.data?.handler?.open?.(ws);
         },
-        message(ws, message) {
-          ws.data?.handler?.message?.(ws, message);
+        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 factory = this.applicationConfig.serverFactory;
     if (!factory && typeof Bun === "undefined") {
-      const { createHttpServer } = await import("./http-server-0xH174zz.js");
+      const { createHttpServer } = await import("./http-server-CCeagTyU.js");
       factory = createHttpServer();
     }
-    const server = factory ? await factory(serveOptions) : Bun.serve(serveOptions);
-    console.log(`Shokupan server listening on http://${serveOptions.hostname}:${serveOptions.port}`);
-    return server;
+    this.server = factory ? await factory(serveOptions) : Bun.serve(serveOptions);
+    return this.server;
+  }
+  /**
+   * Stops the application server.
+   * 
+   * This method gracefully shuts down the server and stops any running monitors.
+   * Works transparently in both Bun and Node.js runtimes.
+   * 
+   * @returns A promise that resolves when the server has been stopped.
+   * 
+   * @example
+   * ```typescript
+   * const app = new Shokupan();
+   * const server = await app.listen(3000);
+   * 
+   * // Later, when you want to stop the server
+   * await app.stop();
+   * ```
+   * @param closeActiveConnections — Immediately terminate in-flight requests, websockets, and stop accepting new connections.
+   */
+  async stop(closeActiveConnections) {
+    if (this.cpuMonitor) {
+      this.cpuMonitor.stop();
+      this.cpuMonitor = void 0;
+    }
+    if (this.server) {
+      await this.server.stop(closeActiveConnections);
+      this.server = void 0;
+    }
   }
   [$dispatch](req) {
     return this.fetch(req);
@@ -2719,7 +3273,7 @@ class Shokupan extends ShokupanRouter {
           const bodyParsing = ["POST", "PUT", "PATCH", "DELETE"].includes(req.method) ? ctx.parseBody() : Promise.resolve();
           const match = this.find(req.method, ctx.path);
           if (match) {
-            ctx._routeMatched = true;
+            ctx[$routeMatched] = true;
             ctx.params = match.params;
             await bodyParsing;
             return match.handler(ctx);
@@ -2729,18 +3283,23 @@ class Shokupan extends ShokupanRouter {
         let response;
         if (result instanceof Response) {
           response = result;
-        } else if ((result === null || result === void 0) && ctx._finalResponse instanceof Response) {
-          response = ctx._finalResponse;
+        } else if ((result === null || result === void 0) && ctx[$finalResponse] instanceof Response) {
+          response = ctx[$finalResponse];
         } else if (result === null || result === void 0) {
-          if (ctx._finalResponse instanceof Response) {
-            response = ctx._finalResponse;
-          } else if (ctx._routeMatched) {
+          if (ctx[$finalResponse] instanceof Response) {
+            response = ctx[$finalResponse];
+          } else if (ctx.isUpgraded) {
+            return void 0;
+          } else if (ctx[$routeMatched]) {
             response = ctx.send(null, { status: ctx.response.status, headers: ctx.response.headers });
           } else {
-            if (ctx.response.status !== 200) {
+            if (ctx.upgrade()) {
+              return void 0;
+            }
+            if (ctx.response.status !== HTTP_STATUS.OK) {
               response = ctx.send(null, { status: ctx.response.status, headers: ctx.response.headers });
             } else {
-              response = ctx.text("Not Found", 404);
+              response = ctx.text("Not Found", HTTP_STATUS.NOT_FOUND);
             }
           }
         } else if (typeof result === "object") {
@@ -2749,13 +3308,15 @@ class Shokupan extends ShokupanRouter {
           response = ctx.text(String(result));
         }
         await this.runHooks("onRequestEnd", ctx);
+        if (response instanceof Promise) {
+          response = await response;
+        }
         await this.runHooks("onResponseStart", ctx, response);
         return response;
       } catch (err) {
-        console.error(err);
         const span = asyncContext.getStore()?.span;
         if (span) span.setStatus({ code: 2 });
-        const status = err.status || err.statusCode || 500;
+        const status = getErrorStatus(err);
         const body = { error: err.message || "Internal Server Error" };
         if (err.errors) body.errors = err.errors;
         await this.runHooks("onError", ctx, err);
@@ -2777,10 +3338,10 @@ class Shokupan extends ShokupanRouter {
     }
     return executionPromise.catch((err) => {
       if (err.message === "Request Timeout") {
-        return ctx.text("Request Timeout", 408);
+        return ctx.text("Request Timeout", HTTP_STATUS.REQUEST_TIMEOUT);
       }
       console.error("Unexpected error in request execution:", err);
-      return ctx.text("Internal Server Error", 500);
+      return ctx.text("Internal Server Error", HTTP_STATUS.INTERNAL_SERVER_ERROR);
     }).then(async (res) => {
       await this.runHooks("onResponseEnd", ctx, res);
       return res;
@@ -2859,8 +3420,7 @@ function RateLimitMiddleware(options = {}) {
         }
       }
       const msg = typeof message === "function" ? message(ctx, key) : message;
-      typeof msg === "object" ? JSON.stringify(msg) : String(msg);
-      const res = typeof msg === "object" ? ctx.json(msg, statusCode) : ctx.text(String(msg), statusCode);
+      const res = await (typeof msg === "object" ? ctx.json(msg, statusCode) : ctx.text(String(msg), statusCode));
       if (headers) {
         setHeaders(res);
         res.headers.set("Retry-After", String(retryAfter));
@@ -2935,8 +3495,12 @@ function createMethodDecorator(method) {
       }
       target[$routeMethods].set(propertyKey, {
         method,
-        path
+        path,
+        source: getCallerInfo(2)
       });
+      if (path.includes("/user")) {
+        console.log(`[Decorator] Captured source for ${propertyKey}:`, getCallerInfo());
+      }
     };
   };
 }
@@ -2948,18 +3512,583 @@ const Patch = createMethodDecorator("PATCH");
 const Options = createMethodDecorator("OPTIONS");
 const Head = createMethodDecorator("HEAD");
 const All = createMethodDecorator("ALL");
+function Event(eventName) {
+  return (target, propertyKey, descriptor) => {
+    target[$eventMethods] ??= /* @__PURE__ */ new Map();
+    target[$eventMethods].set(propertyKey, {
+      eventName
+    });
+  };
+}
 function RateLimit(options) {
   return Use(RateLimitMiddleware(options));
 }
+function AsyncApiApp({ spec, serverUrl, base, disableSourceView, navTree }) {
+  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 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: "stylesheet", href: `${base}/theme.css` }),
+      /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/style.css` }),
+      /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: {
+        __html: `
+                    window.INITIAL_SPEC = ${JSON.stringify(spec)};
+                    window.INITIAL_SERVER_URL = "${serverUrl}";
+                    window.DISABLE_SOURCE_VIEW = ${JSON.stringify(disableSourceView)};
+                `
+      } })
+    ] }),
+    /* @__PURE__ */ jsxs("body", { children: [
+      /* @__PURE__ */ jsxs("div", { class: "app-container", children: [
+        /* @__PURE__ */ jsx(Sidebar, { navTree, disableSourceView }),
+        /* @__PURE__ */ jsx("div", { class: "resizer", id: "resizer-left" }),
+        /* @__PURE__ */ jsx(MainContent, {}),
+        /* @__PURE__ */ jsx("div", { class: "resizer", id: "resizer-right" }),
+        /* @__PURE__ */ jsx(ConsolePanel, { serverUrl })
+      ] }),
+      /* @__PURE__ */ jsx("script", { src: "https://cdn.socket.io/4.7.4/socket.io.min.js" }),
+      /* @__PURE__ */ jsx("script", { src: "https://cdn.jsdelivr.net/npm/monaco-editor@0.45.0/min/vs/loader.js" }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/asyncapi-client.mjs`, type: "module" })
+    ] })
+  ] });
+}
+function Sidebar({ navTree, disableSourceView }) {
+  return /* @__PURE__ */ jsxs("div", { class: "sidebar scroller", id: "sidebar", children: [
+    /* @__PURE__ */ jsxs("div", { class: "sidebar-header", style: "display:flex; justify-content:space-between; align-items:center;", children: [
+      /* @__PURE__ */ jsx("h2", { children: "AsyncAPI" }),
+      /* @__PURE__ */ jsx("button", { id: "btn-collapse-nav", class: "btn-icon", title: "Collapse Sidebar", children: /* @__PURE__ */ jsx("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", children: /* @__PURE__ */ jsx("polyline", { points: "15 18 9 12 15 6" }) }) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { class: "nav-list", id: "nav-list", children: /* @__PURE__ */ jsx(NavNode, { node: navTree, level: 0, disableSourceView }) })
+  ] });
+}
+function NavNode({ node, level, disableSourceView }) {
+  const sortedEntries = Object.entries(node.children || {}).sort((a, b) => {
+    const [aKey, aItem] = a;
+    const [bKey, bItem] = b;
+    const isWarningA = aItem.data?.op?.["x-warning"];
+    const isWarningB = bItem.data?.op?.["x-warning"];
+    if (isWarningA && !isWarningB) return -1;
+    if (!isWarningA && isWarningB) return 1;
+    if (aKey === bKey) return 0;
+    if (aKey === "Warning" || aKey === "Warnings") return -1;
+    if (bKey === "Warning" || bKey === "Warnings") return 1;
+    if (aKey === "Application") return -1;
+    if (bKey === "Application") return 1;
+    if (aKey[0] === "/") return 1;
+    if (bKey[0] === "/") return -1;
+    return aKey.localeCompare(bKey);
+  });
+  return /* @__PURE__ */ jsx(Fragment, { children: sortedEntries.map(([key, item]) => {
+    const hasChildren = Object.keys(item.children || {}).length > 0;
+    if (level === 0) {
+      return /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("div", { class: "group-label", children: key }),
+        hasChildren && /* @__PURE__ */ jsx("div", { class: "tree-node", style: "margin-left: 0", children: /* @__PURE__ */ jsx(NavNode, { node: item, level: level + 1, disableSourceView }) })
+      ] }, key);
+    }
+    const isLeaf = item.isLeaf;
+    return /* @__PURE__ */ jsxs("div", { children: [
+      isLeaf ? /* @__PURE__ */ jsx(LeafNode, { item, label: key, disableSourceView }) : /* @__PURE__ */ jsx("div", { class: "tree-item", style: "color: var(--text-muted)", children: /* @__PURE__ */ jsx("span", { class: "tree-label", children: key }) }),
+      hasChildren && /* @__PURE__ */ jsx("div", { class: "tree-node", children: /* @__PURE__ */ jsx(NavNode, { node: item, level: level + 1, disableSourceView }) })
+    ] }, key);
+  }) });
+}
+function LeafNode({ item, label, disableSourceView }) {
+  const isWarning = item.data?.op?.["x-warning"];
+  const opId = item.data?.name;
+  const sourceInfo = item.data?.op?.["x-source-info"];
+  let content;
+  if (isWarning) {
+    content = /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("span", { style: "margin-right: 6px;", children: "⚠️" }),
+      /* @__PURE__ */ jsx("span", { class: "tree-label", children: label })
+    ] });
+  } else {
+    const badgeText = item.data.type === "publish" ? "SEND" : "RECV";
+    content = /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("span", { class: `badge badge-${badgeText}`, children: badgeText }),
+      /* @__PURE__ */ jsx("span", { class: "tree-label", children: label })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { class: "tree-item", "data-event": opId, style: isWarning ? "color: #fbbf24" : "", children: [
+    content,
+    sourceInfo && !disableSourceView && /* @__PURE__ */ jsx(
+      "a",
+      {
+        href: `vscode://file/${sourceInfo.file}:${sourceInfo.line}`,
+        class: "source-link",
+        onClick: (e) => {
+          e.stopPropagation();
+        },
+        title: `${sourceInfo.file}:${sourceInfo.line}`,
+        children: /* @__PURE__ */ jsxs("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", style: "display:block", children: [
+          /* @__PURE__ */ jsx("polyline", { points: "16 18 22 12 16 6" }),
+          /* @__PURE__ */ jsx("polyline", { points: "8 6 2 12 8 18" })
+        ] })
+      }
+    )
+  ] });
+}
+function MainContent() {
+  return /* @__PURE__ */ jsxs("div", { id: "main-wrapper", style: "flex: 1; min-width: 0; position: relative; overflow: hidden;", children: [
+    /* @__PURE__ */ jsx("button", { id: "btn-expand-nav", class: "btn-icon floating-toggle left", title: "Expand Sidebar", style: "display:none;", children: /* @__PURE__ */ jsx("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", children: /* @__PURE__ */ jsx("polyline", { points: "9 18 15 12 9 6" }) }) }),
+    /* @__PURE__ */ jsx("button", { id: "btn-expand-console", class: "btn-icon floating-toggle right", title: "Expand Console", style: "display:none;", children: /* @__PURE__ */ jsx("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", children: /* @__PURE__ */ jsx("polyline", { points: "15 18 9 12 15 6" }) }) }),
+    /* @__PURE__ */ jsx("main", { class: "main-content scroller", id: "doc-panel", style: "height: 100%;", children: /* @__PURE__ */ jsxs("div", { class: "empty-state", children: [
+      /* @__PURE__ */ jsxs("svg", { viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "1.5", children: [
+        /* @__PURE__ */ jsx("path", { d: "M4 19.5A2.5 2.5 0 0 1 6.5 17H20" }),
+        /* @__PURE__ */ jsx("path", { d: "M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z" })
+      ] }),
+      /* @__PURE__ */ jsx("h3", { children: "Select an event to view details" })
+    ] }) })
+  ] });
+}
+function ConsolePanel({ serverUrl }) {
+  return /* @__PURE__ */ jsxs("div", { class: "console-panel", id: "console-panel", children: [
+    /* @__PURE__ */ jsxs("div", { class: "console-header", children: [
+      /* @__PURE__ */ jsxs("div", { style: "display:flex; justify-content:space-between; align-items:center; margin-bottom: 8px;", children: [
+        /* @__PURE__ */ jsx("h3", { style: "margin:0; font-size:1rem;", children: "Console" }),
+        /* @__PURE__ */ jsxs("div", { style: "display:flex; gap: 4px;", children: [
+          /* @__PURE__ */ jsx("button", { id: "btn-maximize-console", class: "btn-icon", title: "Maximize Console", children: /* @__PURE__ */ jsx("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", children: /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }) }) }),
+          /* @__PURE__ */ jsx("button", { id: "btn-collapse-console", class: "btn-icon", title: "Collapse Console", children: /* @__PURE__ */ jsx("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", children: /* @__PURE__ */ jsx("polyline", { points: "9 18 15 12 9 6" }) }) })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { class: "connection-bar", children: [
+        /* @__PURE__ */ jsxs("select", { id: "protocol", children: [
+          /* @__PURE__ */ jsx("option", { value: "ws", children: "WS" }),
+          /* @__PURE__ */ jsx("option", { value: "wss", children: "WSS" }),
+          /* @__PURE__ */ jsx("option", { value: "socket.io", children: "Socket.IO" })
+        ] }),
+        /* @__PURE__ */ jsx("div", { style: "width: 1px; background: rgba(255,255,255,0.1); margin: 2px 0;" }),
+        /* @__PURE__ */ jsx("input", { type: "text", id: "url", value: serverUrl })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { style: "display: grid; grid-template-columns: 1fr auto; gap: 8px;", children: [
+        /* @__PURE__ */ jsx("button", { id: "connect-btn", class: "btn", children: "Connect" }),
+        /* @__PURE__ */ jsx("button", { id: "clear-logs-btn", class: "btn secondary", title: "Clear Logs", children: /* @__PURE__ */ jsx("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", children: /* @__PURE__ */ jsx("path", { d: "M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" }) }) })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { class: "status-indicator", children: [
+        /* @__PURE__ */ jsx("div", { id: "status-dot", class: "dot" }),
+        /* @__PURE__ */ jsx("span", { id: "connection-status", children: "Disconnected" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { class: "logs-container scroller", id: "logs", children: /* @__PURE__ */ jsx("div", { class: "log-shim", id: "log-shim" }) }),
+    /* @__PURE__ */ jsxs("div", { class: "compose-area", children: [
+      /* @__PURE__ */ jsxs("div", { class: "compose-header", children: [
+        /* @__PURE__ */ jsx("span", { children: "Payload" }),
+        /* @__PURE__ */ jsx("span", { id: "target-event", style: "color: var(--primary);", children: "--" })
+      ] }),
+      /* @__PURE__ */ jsx("div", { id: "editor-container" }),
+      /* @__PURE__ */ jsx("div", { class: "send-bar", children: /* @__PURE__ */ jsx("button", { id: "send-btn", class: "btn", children: "Send Message" }) })
+    ] })
+  ] });
+}
+function buildNavTree(spec) {
+  if (!spec || !spec.channels) return { children: {} };
+  const root = { children: {} };
+  Object.keys(spec.channels).forEach((name) => {
+    const ch = spec.channels[name];
+    const op = ch.publish || ch.subscribe;
+    const type = ch.publish ? "publish" : "subscribe";
+    const tag = op.tags && op.tags.length > 0 ? op.tags[0].name : "General";
+    if (!root.children[tag]) root.children[tag] = { children: {} };
+    const parts = name.split(/[\.\/]/);
+    let current = root.children[tag];
+    parts.forEach((part, i) => {
+      if (!current.children[part]) current.children[part] = { children: {} };
+      current = current.children[part];
+      if (i === parts.length - 1) {
+        current.isLeaf = true;
+        current.data = { name, op, type };
+      }
+    });
+  });
+  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;
+}
+async function generateAsyncApi(rootRouter, options = {}) {
+  const channels = {};
+  let astRoutes = [];
+  try {
+    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-BqIe1p0R.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);
+  } catch (e) {
+  }
+  const matchedAstRoutes = /* @__PURE__ */ new Set();
+  const collect = async (router, prefix = "") => {
+    const eventHandlers = router.getEventHandlers();
+    let routerTag = "Other";
+    if (router[$isApplication]) {
+      routerTag = "Application";
+    } else if (router.constructor.name && router.constructor.name !== "ShokupanRouter") {
+      routerTag = router.constructor.name;
+    } else {
+      routerTag = router[$mountPath] || "Router";
+    }
+    if (eventHandlers) {
+      for (const [eventName, handlers] of eventHandlers.entries()) {
+        for (const handler of handlers) {
+          const userSpec = handler.spec;
+          let tags = userSpec?.tags;
+          if (!tags && routerTag) {
+            tags = [{ name: routerTag }];
+          }
+          let astMatch = astRoutes.find(
+            (r) => (r.method === "EVENT" || r.method === "ON") && r.path === eventName
+          );
+          if (!astMatch) {
+            const runtimeSource = (handler.originalHandler || handler).toString();
+            const stripComments = (s) => s.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
+            const normalize = (s) => stripComments(s).replace(/\s+/g, "");
+            const runtimeHandlerSrc = normalize(runtimeSource);
+            const eventRoutes = astRoutes.filter((r) => r.method === "EVENT" || r.method === "ON");
+            astMatch = eventRoutes.find((r) => {
+              const astHandlerSrc = normalize(r.handlerSource || r.handlerName || "");
+              if (!astHandlerSrc || astHandlerSrc.length < 5) return false;
+              return runtimeHandlerSrc.includes(astHandlerSrc) || astHandlerSrc.includes(runtimeHandlerSrc) || r.handlerSource && runtimeHandlerSrc.includes(normalize(r.handlerSource).substring(0, 50));
+            });
+          }
+          if (astMatch) matchedAstRoutes.add(astMatch);
+          const sourceInfo = handler.source || astMatch?.sourceContext ? {
+            file: handler.source?.file || astMatch?.sourceContext?.file,
+            line: handler.source?.line || astMatch?.sourceContext?.startLine,
+            startLine: handler.source?.line || astMatch?.sourceContext?.startLine,
+            endLine: astMatch?.sourceContext?.endLine,
+            highlightLines: astMatch?.sourceContext ? [astMatch.sourceContext.startLine, astMatch.sourceContext.endLine] : void 0
+          } : void 0;
+          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
+              }
+            };
+            if (userSpec?.summary) channels[eventName].publish.summary = userSpec.summary;
+            if (userSpec?.description) channels[eventName].publish.description = userSpec.description;
+          } else {
+            if (sourceInfo) {
+              if (!channels[eventName].publish["x-source-info"]) {
+                channels[eventName].publish["x-source-info"] = [];
+              }
+              const exists = channels[eventName].publish["x-source-info"].some(
+                (s) => s.file === sourceInfo.file && s.line === sourceInfo.line
+              );
+              if (!exists) {
+                channels[eventName].publish["x-source-info"].push(sourceInfo);
+              }
+            }
+          }
+          let emits = astMatch?.emits || [];
+          for (const emit of emits) {
+            if (emit.event === "__DYNAMIC_EMIT__") {
+              const warningKey = `${eventName}/Dynamic Emit`;
+              channels[warningKey] = {
+                subscribe: {
+                  operationId: `dynamicEmitWarning${eventName}`,
+                  summary: "Dynamic Emit Detected",
+                  description: "This handler emits an event with a dynamic name that could not be determined statically.",
+                  tags,
+                  "x-warning": true,
+                  "x-source-info": {
+                    file: astMatch?.sourceContext?.file,
+                    line: emit.location?.startLine,
+                    startLine: emit.location?.startLine,
+                    endLine: emit.location?.endLine,
+                    highlightLines: emit.location ? [emit.location.startLine, emit.location.endLine] : void 0
+                  },
+                  "x-shokupan-source": {
+                    file: astMatch?.sourceContext?.file,
+                    line: emit.location?.startLine
+                  },
+                  message: { payload: { type: "object" } }
+                }
+              };
+              continue;
+            }
+            const emitStart = emit.location?.startLine;
+            const emitEnd = emit.location?.endLine;
+            const newSourceInfo = sourceInfo && emitStart ? {
+              file: sourceInfo.file,
+              line: emitStart,
+              startLine: emitStart,
+              endLine: emitEnd,
+              highlightLines: sourceInfo.highlightLines,
+              emitHighlightLines: [emitStart, emitEnd]
+            } : void 0;
+            if (!channels[emit.event]) {
+              channels[emit.event] = {
+                subscribe: {
+                  operationId: `emit${emit.event.charAt(0).toUpperCase() + emit.event.slice(1)}`,
+                  tags,
+                  message: {
+                    payload: emit.payload || { type: "object" }
+                  },
+                  "x-source-info": newSourceInfo ? [newSourceInfo] : [],
+                  "x-shokupan-source": sourceInfo && emitStart ? {
+                    file: sourceInfo.file,
+                    line: emitStart
+                  } : void 0
+                }
+              };
+            } else {
+              if (newSourceInfo) {
+                if (!channels[emit.event].subscribe["x-source-info"]) {
+                  channels[emit.event].subscribe["x-source-info"] = [];
+                }
+                const existing = channels[emit.event].subscribe["x-source-info"];
+                const exists = existing.some(
+                  (s) => s.file === newSourceInfo.file && s.line === newSourceInfo.line
+                );
+                if (!exists) {
+                  existing.push(newSourceInfo);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    const httpRoutes = router[$routes];
+    if (httpRoutes) {
+      for (const route of httpRoutes) {
+        const handler = route.handler;
+        let tags = route.handlerSpec?.tags;
+        if (!tags && routerTag) {
+          tags = [{ name: routerTag }];
+        }
+        const methodUpper = route.method.toUpperCase();
+        let astMatch = astRoutes.find(
+          (r) => r.method === methodUpper && (r.path === route.path || r.path === "/" + route.path)
+        );
+        if (!astMatch) {
+          const runtimeSource = (handler.originalHandler || handler).toString();
+          const runtimeHandlerSrc = runtimeSource.replace(/\s+/g, " ");
+          const sameMethodRoutes = astRoutes.filter((r) => r.method === methodUpper);
+          astMatch = sameMethodRoutes.find((r) => {
+            const astHandlerSrc = (r.handlerSource || r.handlerName || "").replace(/\s+/g, " ");
+            if (!astHandlerSrc || astHandlerSrc.length < 20) return false;
+            return runtimeHandlerSrc.includes(astHandlerSrc) || astHandlerSrc.includes(runtimeHandlerSrc) || r.handlerSource && runtimeHandlerSrc.includes(r.handlerSource.substring(0, 50));
+          });
+        }
+        const sourceInfo = handler.source || astMatch?.sourceContext ? {
+          file: handler.source?.file || astMatch?.sourceContext?.file,
+          line: handler.source?.line || astMatch?.sourceContext?.startLine,
+          startLine: handler.source?.line || astMatch?.sourceContext?.startLine,
+          endLine: astMatch?.sourceContext?.endLine,
+          highlightLines: astMatch?.sourceContext ? [astMatch.sourceContext.startLine, astMatch.sourceContext.endLine] : void 0
+        } : void 0;
+        let emits = astMatch?.emits || [];
+        for (const emit of emits) {
+          const emitStart = emit.location?.startLine;
+          const emitEnd = emit.location?.endLine;
+          const newSourceInfo = sourceInfo && emitStart ? {
+            file: sourceInfo.file,
+            line: emitStart,
+            startLine: emitStart,
+            endLine: emitEnd,
+            highlightLines: sourceInfo.highlightLines,
+            emitHighlightLines: [emitStart, emitEnd]
+          } : void 0;
+          if (!channels[emit.event]) {
+            channels[emit.event] = {
+              subscribe: {
+                operationId: `emit${emit.event.charAt(0).toUpperCase() + emit.event.slice(1)}`,
+                tags,
+                message: {
+                  payload: emit.payload || { type: "object" }
+                },
+                "x-source-info": newSourceInfo ? [newSourceInfo] : [],
+                "x-shokupan-source": sourceInfo && emitStart ? {
+                  file: sourceInfo.file,
+                  line: emitStart
+                } : void 0
+              }
+            };
+          } else {
+            if (newSourceInfo) {
+              if (!channels[emit.event].subscribe["x-source-info"]) {
+                channels[emit.event].subscribe["x-source-info"] = [];
+              }
+              const existing = channels[emit.event].subscribe["x-source-info"];
+              const exists = existing.some(
+                (s) => s.file === newSourceInfo.file && s.line === newSourceInfo.line
+              );
+              if (!exists) {
+                existing.push(newSourceInfo);
+              }
+            }
+          }
+        }
+      }
+    }
+    const childRouters = router[$childRouters];
+    for (const child of childRouters) {
+      await collect(child);
+    }
+  };
+  await collect(rootRouter);
+  const dynamicEvents = astRoutes.filter((r) => r.path === "__DYNAMIC_EVENT__" && !matchedAstRoutes.has(r));
+  dynamicEvents.forEach((r, i) => {
+    let prefix = "Anonymous";
+    if (r.handlerName && !r.handlerName.includes("=>") && !r.handlerName.includes("{")) {
+      const parts = r.handlerName.split(".");
+      if (parts.length > 0) prefix = parts[0];
+    }
+    const key = `${prefix}.Dynamic Event ${i + 1}`;
+    channels[key] = {
+      publish: {
+        operationId: `dynamicEventWarning${i}`,
+        summary: "Dynamic Event Detected",
+        description: `A dynamic event listener was detected in your source code but the event name could not be determined statically.`,
+        tags: [{ name: "Warnings" }],
+        "x-warning": true,
+        "x-source-info": {
+          file: r.sourceContext?.file,
+          line: r.sourceContext?.startLine,
+          startLine: r.sourceContext?.startLine,
+          endLine: r.sourceContext?.endLine,
+          highlightLines: r.sourceContext ? [r.sourceContext.startLine, r.sourceContext.endLine] : void 0
+        },
+        "x-shokupan-source": {
+          file: r.sourceContext?.file,
+          line: r.sourceContext?.startLine
+        },
+        message: { payload: { type: "object" } }
+      }
+    };
+  });
+  return {
+    asyncapi: "3.0.0",
+    info: { title: "Shokupan AsyncAPI", version: "1.0.0", ...options.info },
+    channels
+  };
+}
+const generator = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  generateAsyncApi
+}, Symbol.toStringTag, { value: "Module" }));
+class AsyncApiPlugin extends ShokupanRouter {
+  constructor(pluginOptions = {}) {
+    super({ renderer: renderToString });
+    this.pluginOptions = pluginOptions;
+    this.pluginOptions.path ??= "/asyncapi";
+    this.init();
+  }
+  static getBasePath() {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    if (dir.endsWith("dist")) {
+      return dir + "/plugins/application/asyncapi";
+    }
+    return dir;
+  }
+  onInit(app, options) {
+    const path = this.pluginOptions.path || options?.path || "/asyncapi";
+    app.mount(path, this);
+    if (app.applicationConfig.enableAsyncApiGen !== true) {
+      console.warn("AsyncApiPlugin: enableAsyncApiGen is disabled. AsyncApiPlugin will not generate spec.");
+    }
+  }
+  init() {
+    const serveFile = async (ctx, file, type) => {
+      const content = await readFile(join$1(AsyncApiPlugin.getBasePath(), "static", file), "utf-8");
+      ctx.set("Content-Type", type);
+      return ctx.send(content);
+    };
+    this.get("/style.css", (ctx) => serveFile(ctx, "style.css", "text/css"));
+    this.get("/theme.css", (ctx) => serveFile(ctx, "theme.css", "text/css"));
+    this.get("/asyncapi-client.mjs", (ctx) => serveFile(ctx, "asyncapi-client.mjs", "application/javascript"));
+    this.get("/", async (ctx) => {
+      let spec = ctx.app?.asyncApiSpec;
+      if (!spec) {
+        spec = await generateAsyncApi(ctx.app);
+      }
+      if (this.pluginOptions.spec) {
+        deepMerge(spec, this.pluginOptions.spec);
+      }
+      const serverUrl = `${ctx.hostname}:${ctx.app?.applicationConfig.port}`;
+      const base = this.pluginOptions.path;
+      const disableSourceView = this.pluginOptions.disableSourceView;
+      const navTree = buildNavTree(spec);
+      return ctx.jsx(AsyncApiApp({ spec, serverUrl, base, disableSourceView, navTree }));
+    });
+    this.get("/json", async (ctx) => {
+      let spec = ctx.app?.asyncApiSpec;
+      if (!spec) {
+        spec = await generateAsyncApi(ctx.app);
+      }
+      if (this.pluginOptions.spec) {
+        deepMerge(spec, this.pluginOptions.spec);
+      }
+      return ctx.json(spec);
+    });
+    this.get("/_code", async (ctx) => {
+      const file = ctx.query["file"];
+      if (!file || typeof file !== "string") {
+        return ctx.text("Missing file parameter", 400);
+      }
+      try {
+        const content = await readFile(file, "utf8");
+        return ctx.text(content);
+      } catch (e) {
+        return ctx.text("File not found: " + e.message, 404);
+      }
+    });
+  }
+}
 class AuthPlugin extends ShokupanRouter {
   constructor(authConfig) {
     super();
     this.authConfig = authConfig;
     this.secret = typeof authConfig.jwtSecret === "string" ? new TextEncoder().encode(authConfig.jwtSecret) : authConfig.jwtSecret;
-    this.init();
   }
   secret;
-  onInit(app, options) {
+  arctic;
+  jose;
+  async onInit(app, options) {
+    this.arctic = await import("arctic");
+    this.jose = await import("jose");
+    this.init();
     if (options?.path) {
       app.mount(options.path, this);
     } else {
@@ -2967,6 +4096,7 @@ class AuthPlugin extends ShokupanRouter {
     }
   }
   getProviderInstance(name, p) {
+    const { GitHub, Google, MicrosoftEntraId, Apple, Auth0, Okta, OAuth2Client } = this.arctic;
     switch (name) {
       case "github":
         return new GitHub(p.clientId, p.clientSecret, p.redirectUri);
@@ -2994,7 +4124,7 @@ class AuthPlugin extends ShokupanRouter {
   }
   async createSession(user, ctx) {
     const alg = "HS256";
-    const jwt = await new jose.SignJWT({ ...user }).setProtectedHeader({ alg }).setIssuedAt().setExpirationTime(this.authConfig.jwtExpiration || "24h").sign(this.secret);
+    const jwt = await new this.jose.SignJWT({ ...user }).setProtectedHeader({ alg }).setIssuedAt().setExpirationTime(this.authConfig.jwtExpiration || "24h").sign(this.secret);
     const opts = this.authConfig.cookieOptions || {};
     let cookie = `auth_token=${jwt}; Path=${opts.path || "/"}; HttpOnly`;
     if (opts.secure) cookie += "; Secure";
@@ -3004,6 +4134,7 @@ class AuthPlugin extends ShokupanRouter {
     return jwt;
   }
   init() {
+    const { generateState, generateCodeVerifier, GitHub, Google, MicrosoftEntraId, Apple, Auth0, Okta, OAuth2Client } = this.arctic;
     const providerEntries = Object.entries(this.authConfig.providers);
     for (let i = 0; i < providerEntries.length; i++) {
       const [providerName, providerConfig] = providerEntries[i];
@@ -3135,7 +4266,7 @@ class AuthPlugin extends ShokupanRouter {
       };
     } else if (provider === "apple") {
       if (idToken) {
-        const payload = jose.decodeJwt(idToken);
+        const payload = this.jose.decodeJwt(idToken);
         user = {
           id: payload.sub,
           email: payload["email"],
@@ -3166,6 +4297,9 @@ class AuthPlugin extends ShokupanRouter {
    */
   getMiddleware() {
     return async (ctx, next) => {
+      if (!this.jose) {
+        this.jose = await import("jose");
+      }
       const authHeader = ctx.req.headers.get("Authorization");
       let token = authHeader?.startsWith("Bearer ") ? authHeader.substring(7) : null;
       if (!token) {
@@ -3174,7 +4308,7 @@ class AuthPlugin extends ShokupanRouter {
       }
       if (token) {
         try {
-          const { payload } = await jose.jwtVerify(token, this.secret);
+          const { payload } = await this.jose.jwtVerify(token, this.secret);
           ctx.user = payload;
         } catch {
         }
@@ -3291,32 +4425,956 @@ class ClusterPlugin {
     }
   }
 }
-const eta = new Eta();
+function DashboardApp({ metrics, uptime, integrations, base, getRequestHeadersSource }) {
+  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", { 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` }),
+      /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/styles.css` }),
+      /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `${base}/reactflow.css` }),
+      /* @__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__ */ 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: [
+              "Uptime: ",
+              /* @__PURE__ */ jsx("span", { id: "uptime", children: uptime })
+            ] })
+          ] }),
+          /* @__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__ */ 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", { 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", { 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__ */ 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__ */ jsx("script", { dangerouslySetInnerHTML: {
+        __html: `
+                    // Injected function from server config
+                    const getRequestHeaders = ${getRequestHeadersSource};
+                `
+      } }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/poll.js` }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/graph.mjs`, type: "module" }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/charts.js` }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/tables.js` }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/registry.js` }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/failures.js` }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/requests.js` }),
+      /* @__PURE__ */ jsx("script", { src: `${base}/tabs.js` })
+    ] })
+  ] });
+}
+function MetricsGrid({ metrics }) {
+  const total = metrics.totalRequests;
+  const active = metrics.activeRequests;
+  const finished = total - active;
+  const successRate = finished ? Math.round(metrics.successfulRequests / finished * 100) : 100;
+  const failRate = finished ? Math.round(metrics.failedRequests / finished * 100) : 0;
+  return /* @__PURE__ */ jsxs("div", { class: "metrics-grid", children: [
+    /* @__PURE__ */ jsxs("div", { class: "card", children: [
+      /* @__PURE__ */ jsx("div", { class: "card-title", children: "Total Requests" }),
+      /* @__PURE__ */ jsx("div", { class: "card-value", id: "total-requests", children: metrics.totalRequests })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { class: "card", children: [
+      /* @__PURE__ */ jsx("div", { class: "card-title", children: "Active Requests" }),
+      /* @__PURE__ */ jsx("div", { class: "card-value", style: "color: var(--accent)", id: "active-requests", children: metrics.activeRequests })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { class: "card", children: [
+      /* @__PURE__ */ jsx("div", { class: "card-title", children: "Success Rate" }),
+      /* @__PURE__ */ jsx("div", { class: "card-value text-success", children: /* @__PURE__ */ jsxs("span", { id: "success-rate", children: [
+        successRate,
+        "%"
+      ] }) }),
+      /* @__PURE__ */ jsxs("div", { style: "color: var(--text-secondary); margin-top: 0.5rem", children: [
+        /* @__PURE__ */ jsx("span", { id: "successful-requests", children: metrics.successfulRequests }),
+        " successful"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { class: "card", children: [
+      /* @__PURE__ */ jsx("div", { class: "card-title", children: "Fail Rate" }),
+      /* @__PURE__ */ jsx("div", { class: "card-value text-error", children: /* @__PURE__ */ jsxs("span", { id: "fail-rate", children: [
+        failRate,
+        "%"
+      ] }) }),
+      /* @__PURE__ */ jsxs("div", { style: "color: var(--text-secondary); margin-top: 0.5rem", children: [
+        /* @__PURE__ */ jsx("span", { id: "failed-requests", children: metrics.failedRequests }),
+        " failed"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { class: "card", children: [
+      /* @__PURE__ */ jsx("div", { class: "card-title", children: "Avg Latency" }),
+      /* @__PURE__ */ jsxs("div", { class: "card-value", children: [
+        /* @__PURE__ */ jsx("span", { id: "avg-latency", children: metrics.averageTotalTime_ms.toFixed(2) }),
+        " ",
+        /* @__PURE__ */ jsx("span", { style: "font-size: 1rem; color: var(--text-secondary)", children: "ms" })
+      ] })
+    ] })
+  ] });
+}
+function ChartCard({ title, id }) {
+  return /* @__PURE__ */ jsxs("div", { class: "card", style: "height: 300px;", children: [
+    /* @__PURE__ */ jsx("div", { class: "card-title", children: title }),
+    /* @__PURE__ */ jsx("div", { class: "card-chart", children: /* @__PURE__ */ jsx("canvas", { id }) })
+  ] });
+}
+function Card({ title, contentId }) {
+  return /* @__PURE__ */ jsxs("div", { class: "card", children: [
+    /* @__PURE__ */ jsx("div", { class: "card-title", children: title }),
+    /* @__PURE__ */ jsx("div", { id: contentId })
+  ] });
+}
+const INTERVALS = [
+  { label: "10s", ms: 10 * 1e3 },
+  { label: "1m", ms: 60 * 1e3 },
+  { label: "5m", ms: 5 * 60 * 1e3 },
+  { label: "1h", ms: 60 * 60 * 1e3 },
+  { label: "2h", ms: 2 * 60 * 60 * 1e3 },
+  { label: "6h", ms: 6 * 60 * 60 * 1e3 },
+  { label: "12h", ms: 12 * 60 * 60 * 1e3 },
+  { label: "1d", ms: 24 * 60 * 60 * 1e3 },
+  { label: "3d", ms: 3 * 24 * 60 * 60 * 1e3 },
+  { label: "7d", ms: 7 * 24 * 60 * 60 * 1e3 },
+  { label: "30d", ms: 30 * 24 * 60 * 60 * 1e3 }
+];
+class MetricsCollector {
+  constructor(db) {
+    this.db = db;
+    this.eventLoopHistogram.enable();
+    const now = Date.now();
+    INTERVALS.forEach((int) => {
+      this.currentIntervalStart[int.label] = this.alignTimestamp(now, int.ms);
+      this.pendingDetails[int.label] = [];
+    });
+  }
+  currentIntervalStart = {};
+  pendingDetails = {};
+  eventLoopHistogram = monitorEventLoopDelay({ resolution: 10 });
+  timer = null;
+  recordRequest(duration, isError) {
+    INTERVALS.forEach((int) => {
+      this.pendingDetails[int.label].push({ duration, isError });
+    });
+  }
+  alignTimestamp(ts, intervalMs) {
+    return Math.floor(ts / intervalMs) * intervalMs;
+  }
+  async collect() {
+    try {
+      const now = Date.now();
+      for (const int of INTERVALS) {
+        const start = this.currentIntervalStart[int.label];
+        if (now >= start + int.ms) {
+          await this.flushInterval(int.label, start, int.ms);
+          this.currentIntervalStart[int.label] = this.alignTimestamp(now, int.ms);
+        }
+      }
+    } catch (error) {
+      console.error("[MetricsCollector] Error in collect():", error);
+    }
+  }
+  async flushInterval(label, timestamp, durationMs) {
+    const reqs = this.pendingDetails[label];
+    this.pendingDetails[label] = [];
+    if (reqs.length === 0) {
+      return;
+    }
+    const totalReqs = reqs.length;
+    const errorReqs = reqs.filter((r) => r.isError).length;
+    const successReqs = totalReqs - errorReqs;
+    const duratons = reqs.map((r) => r.duration).sort((a, b) => a - b);
+    const rps = totalReqs / (durationMs / 1e3);
+    const sum = duratons.reduce((a, b) => a + b, 0);
+    const avg = totalReqs > 0 ? sum / totalReqs : 0;
+    const getP = (p) => {
+      if (duratons.length === 0) return 0;
+      const idx = Math.floor(duratons.length * p);
+      return duratons[idx];
+    };
+    const metric = {
+      timestamp,
+      interval: label,
+      cpu: os.loadavg()[0],
+      // Using load avg for simplicity as per requirements (Load)
+      load: os.loadavg(),
+      memory: {
+        used: process.memoryUsage().rss,
+        total: os.totalmem(),
+        heapUsed: process.memoryUsage().heapUsed,
+        heapTotal: process.memoryUsage().heapTotal
+      },
+      eventLoopLatency: {
+        min: this.eventLoopHistogram.min / 1e6,
+        max: this.eventLoopHistogram.max / 1e6,
+        mean: this.eventLoopHistogram.mean / 1e6,
+        p50: this.eventLoopHistogram.percentile(50) / 1e6,
+        p95: this.eventLoopHistogram.percentile(95) / 1e6,
+        p99: this.eventLoopHistogram.percentile(99) / 1e6
+      },
+      requests: {
+        total: totalReqs,
+        rps,
+        success: successReqs,
+        error: errorReqs
+      },
+      responseTime: {
+        min: duratons[0] || 0,
+        max: duratons[duratons.length - 1] || 0,
+        avg,
+        p50: getP(0.5),
+        p95: getP(0.95),
+        p99: getP(0.99)
+      }
+    };
+    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 });
+    } catch (e) {
+      console.error(`[MetricsCollector] ✗ Failed to save metrics for ${label}:`, e);
+    }
+  }
+  // Cleanup if needed
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.eventLoopHistogram.disable();
+  }
+}
+class Collector {
+  constructor(dashboard) {
+    this.dashboard = dashboard;
+  }
+  currentNode;
+  trackStep(id, type, duration, status, error) {
+    if (!id) return;
+    this.dashboard.recordNodeMetric(id, type, duration, status === "error");
+  }
+  trackEdge(fromId, toId) {
+    if (!fromId || !toId) return;
+    this.dashboard.recordEdgeMetric(fromId, toId);
+  }
+  setNode(id) {
+    this.currentNode = id;
+  }
+  getCurrentNode() {
+    return this.currentNode;
+  }
+}
+class Dashboard {
+  constructor(dashboardConfig = {}) {
+    this.dashboardConfig = dashboardConfig;
+  }
+  [$appRoot];
+  router = new ShokupanRouter({ renderer: renderToString });
+  metrics = {
+    totalRequests: 0,
+    successfulRequests: 0,
+    failedRequests: 0,
+    activeRequests: 0,
+    averageTotalTime_ms: 0,
+    recentTimings: [],
+    logs: [],
+    rateLimitedCounts: {},
+    nodeMetrics: {},
+    edgeMetrics: {}
+  };
+  startTime = Date.now();
+  instrumented = false;
+  metricsCollector;
+  get db() {
+    return this[$appRoot].db;
+  }
+  // ShokupanPlugin interface implementation
+  onInit(app, options) {
+    this[$appRoot] = app;
+    this.metricsCollector = new MetricsCollector(this.db);
+    const mountPath = options?.path || this.dashboardConfig.path || "/dashboard";
+    const hooks = this.getHooks();
+    if (!app.middleware) {
+      app.middleware = [];
+    }
+    const hooksMiddleware = async (ctx, next) => {
+      if (hooks.onRequestStart) {
+        await hooks.onRequestStart(ctx);
+      }
+      await next();
+      if (hooks.onResponseEnd) {
+        const effectiveResponse = ctx._finalResponse || ctx.response || {};
+        await hooks.onResponseEnd(ctx, effectiveResponse);
+      }
+    };
+    app.use(hooksMiddleware);
+    app.mount(mountPath, this.router);
+    this.setupRoutes();
+  }
+  detectIntegrations() {
+    const integrations = {};
+    const routers = this[$appRoot]?.[$childRouters] || [];
+    const checkConfig = (key) => {
+      const conf = this.dashboardConfig.integrations?.[key];
+      if (conf === false) return { enabled: false };
+      if (typeof conf === "object" && conf.path) return { enabled: true, path: conf.path };
+      return { enabled: true };
+    };
+    const scalarConf = checkConfig("scalar");
+    if (scalarConf.enabled) {
+      if (scalarConf.path) {
+        integrations["scalar"] = scalarConf.path;
+      } else {
+        const plugin = routers.find((r) => r.constructor.name === "ScalarPlugin");
+        if (plugin) {
+          integrations["scalar"] = plugin[$mountPath];
+        }
+      }
+    }
+    const asyncApiConf = checkConfig("asyncapi");
+    if (asyncApiConf.enabled) {
+      if (asyncApiConf.path) {
+        integrations["asyncapi"] = asyncApiConf.path;
+      } else {
+        const plugin = routers.find((r) => r.constructor.name === "AsyncApiPlugin");
+        if (plugin) {
+          integrations["asyncapi"] = plugin[$mountPath];
+        }
+      }
+    }
+    return integrations;
+  }
+  // Get base path for dashboard files - works in both dev (src/) and production (dist/)
+  static getBasePath() {
+    const dir = dirname(fileURLToPath(import.meta.url));
+    if (dir.endsWith("dist")) {
+      return dir + "/plugins/application/dashboard";
+    }
+    return dir;
+  }
+  setupRoutes() {
+    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 interval = ctx.query["interval"];
+      if (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 ms = intervalMap[interval] || 60 * 1e3;
+        const startTime = Date.now() - ms;
+        let stats;
+        try {
+          stats = await this.db.query(`
+                        SELECT 
+                            count() as total,
+                            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 
+                        WHERE timestamp >= $start
+                        GROUP ALL
+                    `, { start: startTime });
+        } catch (error) {
+          console.error("[Dashboard] Query failed at plugin.ts:180-191", {
+            error,
+            interval,
+            startTime,
+            query: "metrics interval stats",
+            stack: new Error().stack
+          });
+          throw error;
+        }
+        const s = stats[0] || { total: 0, success: 0, failed: 0, avg_latency: 0 };
+        return ctx.json({
+          metrics: {
+            totalRequests: s.total || 0,
+            successfulRequests: s.success || 0,
+            failedRequests: s.failed || 0,
+            activeRequests: this.metrics.activeRequests,
+            averageTotalTime_ms: s.avg_latency || 0,
+            recentTimings: this.metrics.recentTimings,
+            logs: [],
+            rateLimitedCounts: this.metrics.rateLimitedCounts,
+            nodeMetrics: this.metrics.nodeMetrics,
+            edgeMetrics: this.metrics.edgeMetrics
+          },
+          uptime
+        });
+      }
+      return ctx.json({
+        metrics: this.metrics,
+        uptime
+      });
+    });
+    this.router.get("/metrics/history", async (ctx) => {
+      const interval = ctx.query["interval"] || "1m";
+      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 * 3;
+      const endTime = Date.now();
+      const result = await this.db.query(
+        "SELECT * FROM metrics WHERE timestamp >= $start AND timestamp <= $end AND interval = $interval ORDER BY timestamp ASC",
+        { start: startTime, end: endTime, interval }
+      );
+      return ctx.json({
+        metrics: result[0] || []
+      });
+    });
+    const getIntervalStartTime = (interval) => {
+      if (!interval) return 0;
+      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 ms = intervalMap[interval] || 0;
+      return ms ? Date.now() - ms : 0;
+    };
+    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",
+        { start: startTime }
+      );
+      return ctx.json({ top: result[0] || [] });
+    });
+    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",
+        { start: startTime }
+      );
+      return ctx.json({ top: result[0] || [] });
+    });
+    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",
+        { start: startTime }
+      );
+      return ctx.json({ top: result[0] || [] });
+    });
+    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",
+        { start: startTime }
+      );
+      return ctx.json({ slowest: result[0] || [] });
+    });
+    this.router.get("/registry", (ctx) => {
+      const app = this[$appRoot];
+      if (!this.instrumented && app) {
+        this.instrumentApp(app);
+      }
+      const registry = app?.getComponentRegistry?.();
+      if (registry) {
+        this.assignIdsToRegistry(registry, "root");
+      }
+      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] || [] });
+    });
+    this.router.get("/requests/:id", async (ctx) => {
+      const result = await this.db.query("SELECT * FROM requests 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");
+      return ctx.json({ failures: result[0] });
+    });
+    this.router.post("/replay", async (ctx) => {
+      const body = await ctx.body();
+      const app = this[$appRoot];
+      if (!app) return unknownError(ctx);
+      try {
+        const result = await app.processRequest({
+          method: body.method,
+          path: body.url,
+          // or path
+          headers: body.headers,
+          body: body.body
+        });
+        return ctx.json({
+          status: result.status,
+          headers: result.headers,
+          data: result.data
+        });
+      } catch (e) {
+        return ctx.json({ error: String(e) }, 500);
+      }
+    });
+    this.router.get("/**", async (ctx) => {
+      const mountPath = this.router[$mountPath] || this.dashboardConfig.path || "/dashboard";
+      let relativePath = ctx.path;
+      if (relativePath.startsWith(mountPath)) {
+        relativePath = relativePath.slice(mountPath.length);
+      }
+      if (relativePath.startsWith("/")) {
+        relativePath = relativePath.slice(1);
+      }
+      const path = relativePath;
+      const staticFiles = [
+        "charts.js",
+        "failures.js",
+        "graph.mjs",
+        "poll.js",
+        "reactflow.css",
+        "registry.css",
+        "registry.js",
+        "requests.js",
+        "styles.css",
+        "tables.js",
+        "tabs.js",
+        "tabulator.css",
+        "theme.css"
+      ];
+      if (staticFiles.includes(path)) {
+        const content = await readFile(join$1(Dashboard.getBasePath(), "static", path), "utf-8");
+        if (path.endsWith(".css")) ctx.set("Content-Type", "text/css");
+        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 integrations = this.detectIntegrations();
+      const getRequestHeadersSource = this.dashboardConfig.getRequestHeaders ? this.dashboardConfig.getRequestHeaders.toString() : "undefined";
+      const html = renderToString(DashboardApp({
+        metrics: this.metrics,
+        uptime,
+        rootPath: process.cwd(),
+        integrations,
+        base: mountPath,
+        getRequestHeadersSource
+      }));
+      return ctx.html(`<!DOCTYPE html>${html}`);
+    });
+  }
+  instrumentApp(app) {
+    if (!app.getComponentRegistry) return;
+    const registry = app.getComponentRegistry();
+    this.assignIdsToRegistry(registry, "root");
+    this.instrumented = true;
+  }
+  // Traverses registry, generates IDs, and attaches them to the actual function objects
+  assignIdsToRegistry(node, parentId) {
+    if (!node) return;
+    const makeId = (type, parent, idx, name) => `${type}_${parent}_${idx}_${name.replace(/[^a-zA-Z0-9]/g, "")}`;
+    node.middleware?.forEach((mw, idx) => {
+      const id = makeId("mw", parentId, idx, mw.name);
+      mw.id = id;
+      if (mw._fn) mw._fn._debugId = id;
+    });
+    node.controllers?.forEach((ctrl, idx) => {
+      const id = makeId("ctrl", parentId, idx, ctrl.name);
+      ctrl.id = id;
+    });
+    node.routes?.forEach((r, idx) => {
+      const id = makeId("route", parentId, idx, r.handlerName || "handler");
+      r.id = id;
+      if (r._fn) r._fn._debugId = id;
+    });
+    node.routers?.forEach((r, idx) => {
+      const id = makeId("router", parentId, idx, r.path);
+      r.id = id;
+      this.assignIdsToRegistry(r.children, id);
+    });
+  }
+  recordNodeMetric(id, type, duration, isError) {
+    if (!this.metrics.nodeMetrics[id]) {
+      this.metrics.nodeMetrics[id] = {
+        id,
+        type,
+        requests: 0,
+        totalTime: 0,
+        failures: 0,
+        name: id
+        // simplify
+      };
+    }
+    const m = this.metrics.nodeMetrics[id];
+    m.requests++;
+    m.totalTime += duration;
+    if (isError) m.failures++;
+  }
+  recordEdgeMetric(from, to) {
+    const key = `${from}|${to}`;
+    this.metrics.edgeMetrics[key] = (this.metrics.edgeMetrics[key] || 0) + 1;
+  }
+  getLinkPattern() {
+    const term = process.env["TERM_PROGRAM"] || "";
+    if (["vscode", "cursor", "antigravity"].some((t) => term.includes(t))) {
+      return "vscode://file/{{absolute}}:{{line}}";
+    }
+    return "file:///{{absolute}}:{{line}}";
+  }
+  getHooks() {
+    return {
+      onRequestStart: (ctx) => {
+        const app = this[$appRoot];
+        if (!this.instrumented && app) {
+          this.instrumentApp(app);
+        }
+        this.metrics.totalRequests++;
+        this.metrics.activeRequests++;
+        ctx._debugStartTime = performance.now();
+        ctx[$debug] = new Collector(this);
+      },
+      onResponseEnd: async (ctx, response) => {
+        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 isError = response.status >= 400;
+        this.metricsCollector.recordRequest(duration, isError);
+        if (response.status >= 400) {
+          this.metrics.failedRequests++;
+          if (response.status === 429) {
+            const path = ctx.path;
+            this.metrics.rateLimitedCounts[path] = (this.metrics.rateLimitedCounts[path] || 0) + 1;
+          }
+          try {
+            const headers = {};
+            if (ctx.request.headers && typeof ctx.request.headers.forEach === "function") {
+              ctx.request.headers.forEach((v, k) => {
+                headers[k] = v;
+              });
+            }
+            await this.db.upsert(new RecordId("failed_requests", ctx.requestId), {
+              method: ctx.method,
+              url: ctx.url.toString(),
+              headers,
+              status: response.status,
+              timestamp: Date.now(),
+              state: ctx.state
+              // body?
+            });
+          } catch (e) {
+            console.error("Failed to record failed request", e);
+          }
+        } else {
+          this.metrics.successfulRequests++;
+        }
+        const logEntry = {
+          method: ctx.method,
+          url: ctx.url.toString(),
+          status: response.status,
+          duration,
+          timestamp: Date.now(),
+          handlerStack: ctx.handlerStack
+        };
+        this.metrics.logs.push(logEntry);
+        try {
+          await this.db.upsert(new RecordId("requests", ctx.requestId), logEntry);
+        } catch (e) {
+          console.error("Failed to record request log", e);
+        }
+        const retention = this.dashboardConfig.retentionMs ?? 72e5;
+        const cutoff = Date.now() - retention;
+        if (this.metrics.logs.length > 0 && this.metrics.logs[0].timestamp < cutoff) {
+          this.metrics.logs = this.metrics.logs.filter((log) => log.timestamp >= cutoff);
+        }
+      }
+    };
+  }
+  updateTiming(duration) {
+    const alpha = 0.1;
+    if (this.metrics.averageTotalTime_ms === 0) {
+      this.metrics.averageTotalTime_ms = duration;
+    } else {
+      this.metrics.averageTotalTime_ms = alpha * duration + (1 - alpha) * this.metrics.averageTotalTime_ms;
+    }
+    this.metrics.recentTimings.push(duration);
+    if (this.metrics.recentTimings.length > 50) {
+      this.metrics.recentTimings.shift();
+    }
+  }
+}
+function unknownError(ctx) {
+  return ctx.json({ error: "Unknown Error" }, 500);
+}
+class GraphQLApolloPlugin extends ShokupanRouter {
+  // Use generic any or verify type
+  constructor(pluginOptions) {
+    super();
+    this.pluginOptions = pluginOptions;
+    this.pluginOptions.path ??= "/graphql";
+  }
+  apolloServer;
+  async onInit(app, options) {
+    const { ApolloServer, HeaderMap } = await import("@apollo/server");
+    this.apolloServer = new ApolloServer({
+      typeDefs: this.pluginOptions.typeDefs,
+      resolvers: this.pluginOptions.resolvers,
+      ...this.pluginOptions.apolloConfig || {}
+    });
+    const path = options?.path || this.pluginOptions.path || "/graphql";
+    app.mount(path, this);
+    app.onStart(async () => {
+      await this.apolloServer.start();
+    });
+    this.post("/", async (ctx) => {
+      const body = await ctx.body();
+      const httpGraphQLResponse = await this.apolloServer.executeHTTPGraphQLRequest({
+        httpGraphQLRequest: {
+          body,
+          method: ctx.req.method,
+          search: ctx.url.search,
+          headers: new HeaderMap(ctx.req.headers)
+        },
+        // Pass the Shokupan Context as the GraphQL Context
+        context: async () => ({ ...ctx, shokupan: ctx })
+      });
+      for (const [key, value] of httpGraphQLResponse.headers) {
+        ctx.set(key, value);
+      }
+      if (httpGraphQLResponse.body.kind === "complete") {
+        return ctx.send(httpGraphQLResponse.body.string, {
+          status: httpGraphQLResponse.status ?? 200
+        });
+      } else {
+        let string = "";
+        for await (const chunk of httpGraphQLResponse.body.asyncIterator) {
+          string += chunk;
+        }
+        return ctx.send(string, {
+          status: httpGraphQLResponse.status ?? 200
+        });
+      }
+    });
+    this.get("/", async (ctx) => {
+      const httpGraphQLResponse = await this.apolloServer.executeHTTPGraphQLRequest({
+        httpGraphQLRequest: {
+          body: Object.keys(ctx.query).length > 0 ? ctx.query : void 0,
+          method: ctx.req.method,
+          search: ctx.url.search,
+          headers: new HeaderMap(ctx.req.headers)
+        },
+        context: async () => ({ ...ctx, shokupan: ctx })
+      });
+      for (const [key, value] of httpGraphQLResponse.headers) {
+        ctx.set(key, value);
+      }
+      if (httpGraphQLResponse.body.kind === "complete") {
+        return ctx.html(httpGraphQLResponse.body.string, httpGraphQLResponse.status ?? 200);
+      } else {
+        let string = "";
+        for await (const chunk of httpGraphQLResponse.body.asyncIterator) {
+          string += chunk;
+        }
+        return ctx.html(string, httpGraphQLResponse.status ?? 200);
+      }
+    });
+  }
+}
 class ScalarPlugin extends ShokupanRouter {
   constructor(pluginOptions = {}) {
     pluginOptions.config ??= {};
     super();
     this.pluginOptions = pluginOptions;
-    this.init();
+    this.initRoutes();
+  }
+  eta;
+  async onInit(app, options) {
+    const { Eta: Eta2 } = await import("eta");
+    this.eta = new Eta2();
+    const path = options?.path || this.pluginOptions.path || "/reference";
+    app.mount(path, this);
+    this.onMount(app);
   }
-  onInit(app, options) {
-    if (options?.path) {
-      app.mount(options.path, this);
-    } else {
-      app.mount(options.path ?? "/", this);
+  async ensureEta() {
+    if (!this.eta) {
+      const { Eta: Eta2 } = await import("eta");
+      this.eta = new Eta2();
     }
-    this.onMount(app);
   }
-  init() {
-    this.get("/", (ctx) => {
+  initRoutes() {
+    const bootId = Date.now().toString();
+    this.get("/_lifecycle", (ctx) => ctx.json({ boot: bootId }));
+    this.get("/", async (ctx) => {
+      await this.ensureEta();
       let path = ctx.url.toString();
       if (!path.endsWith("/")) path += "/";
-      return ctx.html(eta.renderString(`<!doctype html>
-                <html>
+      const devScript = ctx.app?.applicationConfig.development ? `
+                <script>
+                    (function() {
+                        const bootId = "${bootId}";
+                        let isDown = false;
+                        
+                        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;
+                                }
+                            } catch (e) {
+                                isDown = true;
+                                console.log('Connection lost...');
+                            }
+                        }, 2000);
+                    })();
+                <\/script>
+            ` : "";
+      let themeCss = "";
+      try {
+        try {
+          themeCss = readFileSync(join$1(process.cwd(), "src/theme.css"), "utf-8");
+        } catch {
+        }
+      } catch (e) {
+      }
+      if (!this.eta) throw new Error("Eta not initialized");
+      return ctx.html(this.eta.renderString(`<!doctype html>
+                <html lang="en">
                 <head>
                     <title>API Reference</title>
                     <meta charset = "utf-8" />
                     <meta name="viewport" content = "width=device-width, initial-scale=1" />
+                    <style>
+                        ${themeCss}
+                        
+                        :root {
+                            --scalar-color-1: var(--primary);
+                            --scalar-color-2: var(--secondary);
+                            --scalar-color-3: var(--accent);
+                            --scalar-color-accent: var(--accent);
+                            
+                            --scalar-background-1: var(--bg-primary);
+                            --scalar-background-2: var(--bg-secondary);
+                            --scalar-background-3: var(--bg-card);
+                            
+                            --scalar-text-1: var(--text-primary);
+                            --scalar-text-2: var(--text-secondary);
+                            --scalar-text-3: var(--text-muted);
+                            
+                            --scalar-border-color: var(--border-color);
+                        }
+                    </style>
                 </head>
 
                 <body>
@@ -3328,9 +5386,10 @@ class ScalarPlugin extends ShokupanRouter {
                         }
                     ])
                     <\/script>
+                    <%~ it.devScript %>
                 </body>
 
-                </html>`, { path, config: this.pluginOptions }));
+                </html>`, { path, config: this.pluginOptions, devScript }));
     });
     this.get("/openapi.json", async (ctx) => {
       let spec;
@@ -3389,23 +5448,23 @@ function Compression(options = {}) {
       return next();
     }
     let response = await next();
-    if (!(response instanceof Response) && ctx._finalResponse instanceof Response) {
-      response = ctx._finalResponse;
+    if (!(response instanceof Response) && ctx[$finalResponse] instanceof Response) {
+      response = ctx[$finalResponse];
     }
     if (response instanceof Response) {
       if (response.headers.has("Content-Encoding")) return response;
       let body;
       let bodySize;
-      if (ctx._rawBody !== void 0) {
-        if (typeof ctx._rawBody === "string") {
-          const encoded = new TextEncoder().encode(ctx._rawBody);
+      if (ctx[$rawBody] !== void 0) {
+        if (typeof ctx[$rawBody] === "string") {
+          const encoded = new TextEncoder().encode(ctx[$rawBody]);
           body = encoded;
           bodySize = encoded.byteLength;
-        } else if (ctx._rawBody instanceof Uint8Array) {
-          body = ctx._rawBody;
-          bodySize = ctx._rawBody.byteLength;
+        } else if (ctx[$rawBody] instanceof Uint8Array) {
+          body = ctx[$rawBody];
+          bodySize = ctx[$rawBody].byteLength;
         } else {
-          body = ctx._rawBody;
+          body = ctx[$rawBody];
           bodySize = body.byteLength;
         }
       } else {
@@ -3533,7 +5592,7 @@ function Cors(options = {}) {
     }
     const response = await next();
     if (response instanceof Response) {
-      const headerEntries = Array.from(headers.entries());
+      const headerEntries = Object.entries(headers);
       for (let i = 0; i < headerEntries.length; i++) {
         const [key, value] = headerEntries[i];
         response.headers.set(key, value);
@@ -4271,21 +6330,41 @@ function Session(options) {
 }
 export {
   $appRoot,
+  $bodyParseError,
+  $bodyParsed,
+  $bodyType,
+  $cachedBody,
+  $cachedHost,
+  $cachedHostname,
+  $cachedOrigin,
+  $cachedProtocol,
+  $cachedQuery,
   $childControllers,
   $childRouters,
   $controllerPath,
+  $debug,
   $dispatch,
+  $eventMethods,
+  $finalResponse,
+  $io,
   $isApplication,
   $isMounted,
   $isRouter,
   $middleware,
   $mountPath,
   $parent,
+  $rawBody,
+  $requestId,
   $routeArgs,
+  $routeMatched,
   $routeMethods,
   $routeSpec,
   $routes,
+  $socket,
+  $url,
+  $ws,
   All,
+  AsyncApiPlugin,
   AuthPlugin,
   Body,
   ClusterPlugin,
@@ -4294,8 +6373,11 @@ export {
   Controller,
   Cors,
   Ctx,
+  Dashboard,
   Delete,
+  Event,
   Get,
+  GraphQLApolloPlugin,
   HTTPMethods,
   Head,
   Headers$1 as Headers,