shokupan 0.6.1 → 0.9.0

package/dist/index.js

@@ -1,18 +1,122 @@
+import { nanoid } from "nanoid";
 import { readFile } from "node:fs/promises";
+import { trace, SpanKind, SpanStatusCode, context } from "@opentelemetry/api";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Surreal, RecordId } from "surrealdb";
 import { Eta } from "eta";
 import { stat, readdir, readFile as readFile$1 } from "fs/promises";
 import { resolve, join, sep, basename } from "path";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { trace, SpanKind, SpanStatusCode, context } from "@opentelemetry/api";
 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 cluster from "node:cluster";
+import net from "node:net";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { monitorEventLoopDelay } from "node:perf_hooks";
+import { OpenAPIAnalyzer } from "./analyzer-Ce_7JxZh.js";
 import * as zlib from "node:zlib";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import { OpenAPIAnalyzer } from "./openapi-analyzer-Ce_7JxZh.js";
 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,
+  102,
+  103,
+  200,
+  201,
+  202,
+  203,
+  204,
+  205,
+  206,
+  207,
+  208,
+  226,
+  300,
+  301,
+  302,
+  303,
+  304,
+  305,
+  306,
+  307,
+  308,
+  400,
+  401,
+  402,
+  403,
+  404,
+  405,
+  406,
+  407,
+  408,
+  409,
+  410,
+  411,
+  412,
+  413,
+  414,
+  415,
+  416,
+  417,
+  418,
+  421,
+  422,
+  423,
+  424,
+  425,
+  426,
+  428,
+  429,
+  431,
+  451,
+  500,
+  501,
+  502,
+  503,
+  504,
+  505,
+  506,
+  507,
+  508,
+  510,
+  511
+]);
+const VALID_REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
 class ShokupanResponse {
   _headers = null;
   _status = 200;
@@ -76,6 +180,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;
@@ -85,72 +223,6 @@ function isValidCookieDomain(domain, currentHost) {
   }
   return false;
 }
-const VALID_HTTP_STATUSES = /* @__PURE__ */ new Set([
-  100,
-  101,
-  102,
-  103,
-  200,
-  201,
-  202,
-  203,
-  204,
-  205,
-  206,
-  207,
-  208,
-  226,
-  300,
-  301,
-  302,
-  303,
-  304,
-  305,
-  306,
-  307,
-  308,
-  400,
-  401,
-  402,
-  403,
-  404,
-  405,
-  406,
-  407,
-  408,
-  409,
-  410,
-  411,
-  412,
-  413,
-  414,
-  415,
-  416,
-  417,
-  418,
-  421,
-  422,
-  423,
-  424,
-  425,
-  426,
-  428,
-  429,
-  431,
-  451,
-  500,
-  501,
-  502,
-  503,
-  504,
-  505,
-  506,
-  507,
-  508,
-  510,
-  511
-]);
-const VALID_REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
 class ShokupanContext {
   constructor(request, server, state, app, signal, enableMiddlewareTracking = false) {
     this.request = request;
@@ -179,28 +251,43 @@ 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;
+  [$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];
+  [$ws];
+  [$socket];
+  [$io];
+  /**
+   * JSX Rendering Function
+   */
+  renderer;
+  setRenderer(renderer) {
+    this.renderer = renderer;
+  }
+  [$requestId];
+  get requestId() {
+    return this[$requestId] ??= this.app?.applicationConfig?.idGenerator?.() ?? nanoid();
+  }
   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
@@ -218,7 +305,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;
@@ -243,7 +330,7 @@ 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);
@@ -260,7 +347,7 @@ class ShokupanContext {
         q[key] = value;
       }
     }
-    this._cachedQuery = q;
+    this[$cachedQuery] = q;
     return q;
   }
   /**
@@ -273,19 +360,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)
@@ -297,7 +384,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
@@ -318,6 +405,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
@@ -327,6 +432,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
@@ -404,33 +523,37 @@ 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 rawText = await this.readRawBody();
       const parserType = this.app?.applicationConfig?.jsonParser || "native";
       if (parserType === "native") {
-        this._cachedBody = JSON.parse(rawText);
+        try {
+          this[$cachedBody] = await this.request.json();
+        } catch (e) {
+          throw e;
+        }
       } else {
+        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.readRawBody();
-      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.
@@ -438,7 +561,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") {
@@ -447,7 +570,7 @@ class ShokupanContext {
     try {
       await this.body();
     } catch (error) {
-      this._bodyParseError = error;
+      this[$bodyParseError] = error;
     }
   }
   /**
@@ -497,10 +620,21 @@ 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
@@ -511,18 +645,18 @@ class ShokupanContext {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
     const jsonString = JSON.stringify(data);
-    this._rawBody = jsonString;
+    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
@@ -532,18 +666,18 @@ class ShokupanContext {
     if (this.app.applicationConfig.validateStatusCodes && !VALID_HTTP_STATUSES.has(finalStatus)) {
       throw new Error(`Invalid HTTP status code: ${finalStatus}`);
     }
-    this._rawBody = data;
+    this[$rawBody] = data;
     if (!headers && !this.response.hasPopulatedHeaders) {
-      this._finalResponse = new Response(data, {
+      this[$finalResponse] = new Response(data, {
         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(data, { status: finalStatus, headers: finalHeaders });
+    return this[$finalResponse];
   }
   /**
    * Respond with HTML content
@@ -555,9 +689,9 @@ class ShokupanContext {
     }
     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;
+    this[$finalResponse] = new Response(html, { status: finalStatus, headers: finalHeaders });
+    return this[$finalResponse];
   }
   /**
    * Respond with a redirect
@@ -568,8 +702,8 @@ class ShokupanContext {
     }
     const headers = this.mergeHeaders();
     headers.set("Location", url);
-    this._finalResponse = new Response(null, { status, headers });
-    return this._finalResponse;
+    this[$finalResponse] = new Response(null, { status, headers });
+    return this[$finalResponse];
   }
   /**
    * Respond with a status code
@@ -580,8 +714,8 @@ class ShokupanContext {
       throw new Error(`Invalid HTTP status code: ${status}`);
     }
     const headers = this.mergeHeaders();
-    this._finalResponse = new Response(null, { status, headers });
-    return this._finalResponse;
+    this[$finalResponse] = new Response(null, { status, headers });
+    return this[$finalResponse];
   }
   /**
    * Respond with a file
@@ -593,21 +727,17 @@ class ShokupanContext {
       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 });
+      return this[$finalResponse];
     } else {
       const fileBuffer = await readFile(path);
       if (fileOptions?.type) {
         headers.set("content-type", fileOptions.type);
       }
-      this._finalResponse = new Response(fileBuffer, { status, headers });
-      return this._finalResponse;
+      this[$finalResponse] = new Response(fileBuffer, { status, headers });
+      return this[$finalResponse];
     }
   }
-  /**
-   * JSX Rendering Function
-   */
-  renderer;
   /**
    * Render a JSX element
    * @param element JSX Element
@@ -626,284 +756,67 @@ class ShokupanContext {
     return this.html(html, status, headers);
   }
 }
-function RateLimitMiddleware(options = {}) {
-  const windowMs = options.windowMs || 60 * 1e3;
-  const max = options.limit || options.max || 5;
-  const message = options.message || "Too many requests, please try again later.";
-  const statusCode = options.statusCode || 429;
-  const headers = options.headers !== false;
-  const mode = options.mode || "user";
-  const trustedProxies = options.trustedProxies || [];
-  const keyGenerator = options.keyGenerator || ((ctx) => {
-    if (mode === "absolute") {
-      return "global";
-    }
-    const xForwardedFor = ctx.headers.get("x-forwarded-for");
-    if (xForwardedFor && trustedProxies.length > 0) {
-      const ips = xForwardedFor.split(",").map((ip) => ip.trim());
-      for (let i = ips.length - 1; i >= 0; i--) {
-        const ip = ips[i];
-        if (!trustedProxies.includes(ip)) {
-          if (/^[\d.:a-fA-F]+$/.test(ip)) {
-            return ip;
-          }
-        }
+const compose = (middleware) => {
+  if (!middleware.length) {
+    return (context2, next) => {
+      return next ? next() : Promise.resolve();
+    };
+  }
+  return function dispatch(context2, next) {
+    let index = -1;
+    async function runner(i) {
+      if (i <= index) return Promise.reject(new Error("next() called multiple times"));
+      index = i;
+      if (i >= middleware.length) {
+        return next ? next() : Promise.resolve();
       }
-    }
-    return ctx.server?.requestIP?.(ctx.request)?.address || "unknown";
-  });
-  const skip = options.skip || (() => false);
-  const hits = /* @__PURE__ */ new Map();
-  const interval = setInterval(() => {
-    const now = Date.now();
-    const entries = Array.from(hits.entries());
-    for (let i = 0; i < entries.length; i++) {
-      const [key, record] = entries[i];
-      if (record.resetTime <= now) {
-        hits.delete(key);
+      const fn = middleware[i];
+      if (!context2[$debug]) {
+        return fn(context2, () => runner(i + 1));
+      }
+      const debug = context2[$debug];
+      const debugId = fn._debugId || fn.name || "anonymous";
+      const previousNode = debug.getCurrentNode();
+      debug.trackEdge(previousNode, debugId);
+      debug.setNode(debugId);
+      const start = performance.now();
+      try {
+        const res = await Promise.resolve(fn(context2, () => runner(i + 1)));
+        debug.trackStep(debugId, "middleware", performance.now() - start, "success");
+        return res;
+      } catch (err) {
+        debug.trackStep(debugId, "middleware", performance.now() - start, "error", err);
+        return Promise.reject(err);
+      } finally {
+        if (previousNode) debug.setNode(previousNode);
       }
     }
-  }, windowMs);
-  if (interval.unref) interval.unref();
-  const rateLimitMiddleware = async function RateLimitMiddleware2(ctx, next) {
-    if (skip(ctx)) return next();
-    const key = keyGenerator(ctx);
-    const now = Date.now();
-    let record = hits.get(key);
-    if (!record || record.resetTime <= now) {
-      record = {
-        hits: 0,
-        resetTime: now + windowMs
-      };
-      hits.set(key, record);
-    }
-    record.hits++;
-    const remaining = Math.max(0, max - record.hits);
-    const resetTime = Math.ceil(record.resetTime / 1e3);
-    const retryAfter = Math.ceil((record.resetTime - now) / 1e3);
-    const setHeaders = (res) => {
-      if (!headers || !res || !res.headers) return;
-      try {
-        res.headers.set("X-RateLimit-Limit", String(max));
-        res.headers.set("X-RateLimit-Remaining", String(remaining));
-        res.headers.set("X-RateLimit-Reset", String(resetTime));
-      } catch (e) {
-      }
-    };
-    if (record.hits > max) {
-      typeof message === "object" ? JSON.stringify(message) : String(message);
-      const res = typeof message === "object" ? ctx.json(message, statusCode) : ctx.text(String(message), statusCode);
-      if (headers) {
-        setHeaders(res);
-        res.headers.set("Retry-After", String(retryAfter));
-      }
-      return res;
-    }
-    const response = await next();
-    if (response instanceof Response && headers) {
-      setHeaders(response);
-    }
-    return response;
-  };
-  rateLimitMiddleware.isBuiltin = true;
-  rateLimitMiddleware.pluginName = "RateLimit";
-  return rateLimitMiddleware;
-}
-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 HTTPMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "ALL"];
-var RouteParamType = /* @__PURE__ */ ((RouteParamType2) => {
-  RouteParamType2["BODY"] = "BODY";
-  RouteParamType2["PARAM"] = "PARAM";
-  RouteParamType2["QUERY"] = "QUERY";
-  RouteParamType2["HEADER"] = "HEADER";
-  RouteParamType2["REQUEST"] = "REQUEST";
-  RouteParamType2["CONTEXT"] = "CONTEXT";
-  return RouteParamType2;
-})(RouteParamType || {});
-function Controller(path = "/") {
-  return (target) => {
-    target[$controllerPath] = path;
-  };
-}
-function Use(...middleware) {
-  return (target, propertyKey, descriptor) => {
-    if (!propertyKey) {
-      const existing = target[$middleware] || [];
-      target[$middleware] = [...existing, ...middleware];
-    } else {
-      if (!target[$middleware]) {
-        target[$middleware] = /* @__PURE__ */ new Map();
-      }
-      const existing = target[$middleware].get(propertyKey) || [];
-      target[$middleware].set(propertyKey, [...existing, ...middleware]);
-    }
-  };
-}
-function createParamDecorator(type) {
-  return (name) => {
-    return (target, propertyKey, parameterIndex) => {
-      if (!target[$routeArgs]) {
-        target[$routeArgs] = /* @__PURE__ */ new Map();
-      }
-      if (!target[$routeArgs].has(propertyKey)) {
-        target[$routeArgs].set(propertyKey, []);
-      }
-      target[$routeArgs].get(propertyKey).push({
-        index: parameterIndex,
-        type,
-        name
-      });
-    };
-  };
-}
-const Body = createParamDecorator(RouteParamType.BODY);
-const Param = createParamDecorator(RouteParamType.PARAM);
-const Query = createParamDecorator(RouteParamType.QUERY);
-const Headers$1 = createParamDecorator(RouteParamType.HEADER);
-const Req = createParamDecorator(RouteParamType.REQUEST);
-const Ctx = createParamDecorator(RouteParamType.CONTEXT);
-function Spec(spec) {
-  return (target, propertyKey, descriptor) => {
-    if (!target[$routeSpec]) {
-      target[$routeSpec] = /* @__PURE__ */ new Map();
-    }
-    target[$routeSpec].set(propertyKey, spec);
-  };
-}
-function createMethodDecorator(method) {
-  return (path = "/") => {
-    return (target, propertyKey, descriptor) => {
-      if (!target[$routeMethods]) {
-        target[$routeMethods] = /* @__PURE__ */ new Map();
-      }
-      target[$routeMethods].set(propertyKey, {
-        method,
-        path
-      });
-    };
-  };
-}
-const Get = createMethodDecorator("GET");
-const Post = createMethodDecorator("POST");
-const Put = createMethodDecorator("PUT");
-const Delete = createMethodDecorator("DELETE");
-const Patch = createMethodDecorator("PATCH");
-const Options = createMethodDecorator("OPTIONS");
-const Head = createMethodDecorator("HEAD");
-const All = createMethodDecorator("ALL");
-function RateLimit(options) {
-  return Use(RateLimitMiddleware(options));
-}
-class Container {
-  static services = /* @__PURE__ */ new Map();
-  static register(target, instance) {
-    this.services.set(target, instance);
-  }
-  static get(target) {
-    return this.services.get(target);
-  }
-  static has(target) {
-    return this.services.has(target);
-  }
-  static resolve(target) {
-    if (this.services.has(target)) {
-      return this.services.get(target);
-    }
-    const instance = new target();
-    this.services.set(target, instance);
-    return instance;
-  }
-}
-function Injectable() {
-  return (target) => {
-  };
-}
-function Inject(token) {
-  return (target, key) => {
-    Object.defineProperty(target, key, {
-      get: () => Container.resolve(token),
-      enumerable: true,
-      configurable: true
-    });
+    return runner(0);
   };
-}
-const compose = (middleware) => {
-  if (!middleware.length) {
-    return (context2, next) => {
-      return next ? next() : Promise.resolve();
-    };
-  }
-  return function dispatch(context2, next) {
-    let index = -1;
-    async function runner(i) {
-      if (i <= index) return Promise.reject(new Error("next() called multiple times"));
-      index = i;
-      if (i >= middleware.length) {
-        return next ? next() : Promise.resolve();
-      }
-      const fn = middleware[i];
-      if (!context2._debug) {
-        return fn(context2, () => runner(i + 1));
+};
+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"
       }
-      const debug = context2._debug;
-      const debugId = fn._debugId || fn.name || "anonymous";
-      const previousNode = debug.getCurrentNode();
-      debug.trackEdge(previousNode, debugId);
-      debug.setNode(debugId);
-      const start = performance.now();
+    }, async (span) => {
       try {
-        const res = await Promise.resolve(fn(context2, () => runner(i + 1)));
-        debug.trackStep(debugId, "middleware", performance.now() - start, "success");
-        return res;
+        const result = await fn.apply(this, args);
+        return result;
       } catch (err) {
-        debug.trackStep(debugId, "middleware", performance.now() - start, "error", err);
-        return Promise.reject(err);
+        span.recordException(err);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+        throw err;
       } finally {
-        if (previousNode) debug.setNode(previousNode);
+        span.end();
       }
-    }
-    return runner(0);
+    });
   };
-};
-class ShokupanRequestBase {
-  method;
-  url;
-  headers;
-  body;
-  async json() {
-    return JSON.parse(this.body);
-  }
-  async text() {
-    return this.body;
-  }
-  async formData() {
-    if (this.body instanceof FormData) {
-      return this.body;
-    }
-    return new Response(this.body, { headers: this.headers }).formData();
-  }
-  constructor(props) {
-    Object.assign(this, props);
-    if (!(this.headers instanceof Headers)) {
-      this.headers = new Headers(this.headers);
-    }
-  }
 }
-const ShokupanRequest = ShokupanRequestBase;
 function isObject(item) {
   return item && typeof item === "object" && !Array.isArray(item);
 }
@@ -1129,7 +1042,7 @@ async function generateOpenApi(rootRouter, options = {}) {
   const defaultTagName = options.defaultTag || "Application";
   let astRoutes = [];
   try {
-    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./openapi-analyzer-Ce_7JxZh.js");
+    const { OpenAPIAnalyzer: OpenAPIAnalyzer2 } = await import("./analyzer-Ce_7JxZh.js");
     const analyzer = new OpenAPIAnalyzer2(process.cwd());
     const { applications } = await analyzer.analyze();
     astRoutes = await getAstRoutes(applications);
@@ -1318,6 +1231,40 @@ async function generateOpenApi(rootRouter, options = {}) {
     "x-tagGroups": xTagGroups
   };
 }
+class RequestContextStore {
+  request;
+  span;
+}
+const asyncContext = new AsyncLocalStorage();
+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$1 = new Eta();
 function serveStatic(config, prefix) {
   const rootPath = resolve(config.root || ".");
@@ -1470,14 +1417,162 @@ function serveStatic(config, prefix) {
   serveStaticMiddleware.pluginName = "ServeStatic";
   return serveStaticMiddleware;
 }
-class RouterTrie {
-  root;
-  constructor() {
-    this.root = this.createNode();
-  }
-  createNode() {
-    return {
-      children: {}
+const G = globalThis;
+G.__shokupan_db = G.__shokupan_db || null;
+G.__shokupan_db_promise = G.__shokupan_db_promise || null;
+async function ensureDb() {
+  if (G.__shokupan_db) return G.__shokupan_db;
+  if (G.__shokupan_db_promise) return G.__shokupan_db_promise;
+  G.__shokupan_db_promise = (async () => {
+    try {
+      const { createNodeEngines } = await import("@surrealdb/node");
+      const surreal = await import("surrealdb");
+      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";
+            DEFINE TABLE OVERWRITE metrics SCHEMALESS COMMENT "Created by Shokupan";
+        `);
+      G.__shokupan_db = _db;
+      return _db;
+    } catch (e) {
+      G.__shokupan_db_promise = 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 G.__shokupan_db_promise;
+}
+const datastore = {
+  async get(recordId) {
+    await ensureDb();
+    return G.__shokupan_db.select(recordId);
+  },
+  async set(recordId, value) {
+    await ensureDb();
+    return G.__shokupan_db.upsert(recordId).content(value);
+  },
+  async query(query, vars) {
+    await ensureDb();
+    try {
+      return G.__shokupan_db.query(query, vars).collect();
+    } catch (e) {
+      console.error("DS ERROR:", e);
+      throw e;
+    }
+  },
+  get ready() {
+    return ensureDb().then(() => void 0);
+  }
+};
+process.on("exit", async () => {
+  if (G.__shokupan_db) await G.__shokupan_db.close();
+});
+class Container {
+  static services = /* @__PURE__ */ new Map();
+  static register(target, instance) {
+    this.services.set(target, instance);
+  }
+  static get(target) {
+    return this.services.get(target);
+  }
+  static has(target) {
+    return this.services.has(target);
+  }
+  static resolve(target) {
+    if (this.services.has(target)) {
+      return this.services.get(target);
+    }
+    const instance = new target();
+    this.services.set(target, instance);
+    return instance;
+  }
+}
+function Injectable() {
+  return (target) => {
+  };
+}
+function Inject(token) {
+  return (target, key) => {
+    Object.defineProperty(target, key, {
+      get: () => Container.resolve(token),
+      enumerable: true,
+      configurable: true
+    });
+  };
+}
+class ShokupanRequestBase {
+  method;
+  url;
+  headers;
+  body;
+  async json() {
+    return JSON.parse(this.body);
+  }
+  async text() {
+    return this.body;
+  }
+  async formData() {
+    if (this.body instanceof FormData) {
+      return this.body;
+    }
+    return new Response(this.body, { headers: this.headers }).formData();
+  }
+  constructor(props) {
+    Object.assign(this, props);
+    if (!(this.headers instanceof Headers)) {
+      this.headers = new Headers(this.headers);
+    }
+  }
+}
+const ShokupanRequest = ShokupanRequestBase;
+function getCallerInfo(skipFrames = 1) {
+  let file = "unknown";
+  let line = 0;
+  try {
+    const err = new Error();
+    const stack = err.stack?.split("\n") || [];
+    let found = 0;
+    for (let i = 1; i < stack.length; i++) {
+      const l = stack[i];
+      if (!l.includes(":")) continue;
+      if (l.includes("node_modules")) continue;
+      if (l.includes("bun:main")) continue;
+      if (l.includes("src/util/stack.ts")) continue;
+      if (l.includes("src/router.ts")) continue;
+      if (l.includes("src/shokupan.ts")) continue;
+      found++;
+      if (found >= skipFrames) {
+        const match = l.match(/\((.*):(\d+):(\d+)\)/) || l.match(/at (.*):(\d+):(\d+)/);
+        if (match) {
+          file = match[1];
+          line = parseInt(match[2], 10);
+          return { file, line };
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return { file, line };
+}
+class RouterTrie {
+  root;
+  constructor() {
+    this.root = this.createNode();
+  }
+  createNode() {
+    return {
+      children: {}
     };
   }
   insert(method, path, handler) {
@@ -1570,124 +1665,16 @@ class RouterTrie {
     return s.split("/");
   }
 }
-const asyncContext = new AsyncLocalStorage();
-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();
-});
-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 getCallerInfo(skipFrames = 1) {
-  let file = "unknown";
-  let line = 0;
-  try {
-    const err = new Error();
-    const stack = err.stack?.split("\n") || [];
-    let found = 0;
-    for (let i = 1; i < stack.length; i++) {
-      const l = stack[i];
-      if (!l.includes(":")) continue;
-      if (l.includes("node_modules")) continue;
-      if (l.includes("bun:main")) continue;
-      if (l.includes("src/util/stack.ts")) continue;
-      if (l.includes("src/router.ts")) continue;
-      if (l.includes("src/shokupan.ts")) continue;
-      found++;
-      if (found >= skipFrames) {
-        const match = l.match(/\((.*):(\d+):(\d+)\)/) || l.match(/at (.*):(\d+):(\d+)/);
-        if (match) {
-          file = match[1];
-          line = parseInt(match[2], 10);
-          return { file, line };
-        }
-      }
-    }
-  } catch (e) {
-  }
-  return { file, line };
-}
-const RouterRegistry = /* @__PURE__ */ new Map();
-const ShokupanApplicationTree = {};
+const HTTPMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "ALL"];
+var RouteParamType = /* @__PURE__ */ ((RouteParamType2) => {
+  RouteParamType2["BODY"] = "BODY";
+  RouteParamType2["PARAM"] = "PARAM";
+  RouteParamType2["QUERY"] = "QUERY";
+  RouteParamType2["HEADER"] = "HEADER";
+  RouteParamType2["REQUEST"] = "REQUEST";
+  RouteParamType2["CONTEXT"] = "CONTEXT";
+  return RouteParamType2;
+})(RouteParamType || {});
 class ShokupanRouter {
   constructor(config) {
     this.config = config;
@@ -1720,6 +1707,7 @@ class ShokupanRouter {
   metadata;
   // Metadata for the router itself
   currentGuards = [];
+  eventHandlers = /* @__PURE__ */ new Map();
   // Registry Accessor
   getComponentRegistry() {
     const controllerRoutesMap = /* @__PURE__ */ new Map();
@@ -1781,233 +1769,54 @@ class ShokupanRouter {
     return typeof target === "object" && target !== null && $isRouter in target;
   }
   /**
-   * Mounts a controller instance to a path prefix.
-   * 
-   * Controller can be a convection router or an arbitrary class.
-   * 
-   * Routes are derived from method names:
-   * - get(ctx) -> GET /prefix/
-   * - getUsers(ctx) -> GET /prefix/users
-   * - postCreate(ctx) -> POST /prefix/create
+   * Registers an event handler for WebSocket.
    */
-  mount(prefix, controller) {
-    const isRouter = this.isRouterInstance(controller);
+  event(name, handler) {
+    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;
+  }
+  /**
+   * Mounts a controller instance to a path prefix.
+   * 
+   * Controller can be a convection router or an arbitrary class.
+   * 
+   * Routes are derived from method names:
+   * - get(ctx) -> GET /prefix/
+   * - getUsers(ctx) -> GET /prefix/users
+   * - postCreate(ctx) -> POST /prefix/create
+   */
+  mount(prefix, controller) {
+    const isRouter = this.isRouterInstance(controller);
     const isFunction = typeof controller === "function";
     const controllersOnly = this.config?.controllersOnly ?? this.rootConfig?.controllersOnly ?? false;
     if (controllersOnly && !isFunction && !isRouter) {
       throw new Error(`[Shokupan] strict controller check failed: ${controller.constructor.name || typeof controller} is not a class constructor.`);
     }
     if (this.isRouterInstance(controller)) {
-      if (controller[$isMounted]) {
-        throw new Error("Router is already mounted");
-      }
-      controller[$mountPath] = prefix;
-      if (!controller.metadata) {
-        const info = getCallerInfo();
-        controller.metadata = {
-          file: info.file,
-          line: info.line,
-          name: "MountedRouter"
-        };
-      }
-      this[$childRouters].push(controller);
-      controller[$parent] = this;
-      const setRouterContext = (router) => {
-        router[$appRoot] = this.root;
-        router[$childRouters].forEach((child) => setRouterContext(child));
-      };
-      setRouterContext(controller);
-      if (this[$appRoot]) ;
-      controller[$appRoot] = this.root;
-      controller[$isMounted] = true;
+      this.mountRouter(prefix, controller);
     } else {
-      let instance = controller;
-      if (typeof controller === "function") {
-        instance = Container.resolve(controller);
-        const controllerPath = controller[$controllerPath];
-        if (controllerPath) {
-          const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-          const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
-          prefix = p1 + p2;
-          if (!prefix) prefix = "/";
-        }
-      } else {
-        const ctor = instance.constructor;
-        const controllerPath = ctor[$controllerPath];
-        if (controllerPath) {
-          const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-          const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
-          prefix = p1 + p2;
-          if (!prefix) prefix = "/";
-        }
-      }
-      instance[$mountPath] = prefix;
-      const info = getCallerInfo();
-      instance.metadata = {
-        file: info.file,
-        line: info.line,
-        name: instance.constructor.name
-      };
-      this[$childControllers].push(instance);
-      const controllerMiddleware = (typeof controller === "function" ? controller[$middleware] : instance[$middleware]) || [];
-      const proto = Object.getPrototypeOf(instance);
-      const methods = /* @__PURE__ */ new Set();
-      let current = proto;
-      while (current && current !== Object.prototype) {
-        Object.getOwnPropertyNames(current).forEach((name) => methods.add(name));
-        current = Object.getPrototypeOf(current);
-      }
-      Object.getOwnPropertyNames(instance).forEach((name) => methods.add(name));
-      const decoratedRoutes = instance[$routeMethods] || proto && proto[$routeMethods];
-      const decoratedArgs = instance[$routeArgs] || proto && proto[$routeArgs];
-      const methodMiddlewareMap = instance[$middleware] || proto && proto[$middleware];
-      let routesAttached = 0;
-      for (let i = 0; i < Array.from(methods).length; i++) {
-        const name = Array.from(methods)[i];
-        if (name === "constructor") continue;
-        if (["arguments", "caller", "callee"].includes(name)) continue;
-        const originalHandler = instance[name];
-        if (typeof originalHandler !== "function") continue;
-        let method;
-        let subPath = "";
-        if (decoratedRoutes && decoratedRoutes.has(name)) {
-          const config = decoratedRoutes.get(name);
-          method = config.method;
-          subPath = config.path;
-        } else {
-          for (let j = 0; j < HTTPMethods.length; j++) {
-            const m = HTTPMethods[j];
-            if (name.toUpperCase().startsWith(m)) {
-              method = m;
-              const rest = name.slice(m.length);
-              if (rest.length === 0) {
-                subPath = "/";
-              } else {
-                subPath = "";
-                let buffer = "";
-                const flush = () => {
-                  if (buffer.length > 0) {
-                    subPath += "/" + buffer.toLowerCase();
-                    buffer = "";
-                  }
-                };
-                for (let i2 = 0; i2 < rest.length; i2++) {
-                  const char = rest[i2];
-                  if (char === "$") {
-                    flush();
-                    subPath += "/:";
-                    continue;
-                  }
-                }
-                subPath = rest.replace(/\$/g, "/:").replace(/([a-z0-9])([A-Z])/g, "$1/$2").toLowerCase();
-                if (!subPath.startsWith("/")) {
-                  subPath = "/" + subPath;
-                }
-              }
-              break;
-            }
-          }
-        }
-        if (method) {
-          routesAttached++;
-          const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
-          const cleanSubPath = subPath === "/" ? "" : subPath;
-          let joined;
-          if (cleanSubPath.length === 0) {
-            joined = cleanPrefix;
-          } else if (cleanSubPath.startsWith("/")) {
-            joined = cleanPrefix + cleanSubPath;
-          } else {
-            joined = cleanPrefix + "/" + cleanSubPath;
-          }
-          const fullPath = joined || "/";
-          const normalizedPath = fullPath.replace(/\/+/g, "/");
-          const methodMw = methodMiddlewareMap instanceof Map ? methodMiddlewareMap.get(name) || [] : [];
-          const allMiddleware = [...controllerMiddleware, ...methodMw];
-          const routeArgs = decoratedArgs && decoratedArgs.get(name);
-          const wrappedHandler = async (ctx) => {
-            let args = [ctx];
-            if (routeArgs?.length > 0) {
-              args = [];
-              const sortedArgs = [...routeArgs].sort((a, b) => a.index - b.index);
-              for (let k = 0; k < sortedArgs.length; k++) {
-                const arg = sortedArgs[k];
-                switch (arg.type) {
-                  case RouteParamType.BODY:
-                    try {
-                      if (ctx.req.headers.get("content-type")?.includes("application/json")) {
-                        args[arg.index] = await ctx.req.json();
-                      } else {
-                        const text = await ctx.req.text();
-                        if (!text) {
-                          args[arg.index] = {};
-                        } else {
-                          args[arg.index] = JSON.parse(text);
-                        }
-                      }
-                    } catch (e) {
-                      const err = new Error("Invalid JSON body");
-                      err.status = 400;
-                      throw err;
-                    }
-                    break;
-                  case RouteParamType.PARAM:
-                    args[arg.index] = arg.name ? ctx.params[arg.name] : ctx.params;
-                    break;
-                  case RouteParamType.QUERY: {
-                    const url = new URL(ctx.req.url);
-                    if (arg.name) {
-                      const vals = url.searchParams.getAll(arg.name);
-                      args[arg.index] = vals.length > 1 ? vals : vals[0];
-                    } else {
-                      const query = {};
-                      const keys = Object.keys(url.searchParams);
-                      for (let k2 = 0; k2 < keys.length; k2++) {
-                        const key = keys[k2];
-                        const vals = url.searchParams.getAll(key);
-                        query[key] = vals.length > 1 ? vals : vals[0];
-                      }
-                      args[arg.index] = query;
-                    }
-                    break;
-                  }
-                  case RouteParamType.HEADER:
-                    args[arg.index] = arg.name ? ctx.req.headers.get(arg.name) : ctx.req.headers;
-                    break;
-                  case RouteParamType.REQUEST:
-                    args[arg.index] = ctx.req;
-                    break;
-                  case RouteParamType.CONTEXT:
-                    args[arg.index] = ctx;
-                    break;
-                }
-              }
-            }
-            const tracedOriginalHandler = ctx.app?.applicationConfig.enableTracing ? traceHandler(originalHandler, normalizedPath) : originalHandler;
-            return tracedOriginalHandler.apply(instance, args);
-          };
-          let finalHandler = wrappedHandler;
-          if (allMiddleware.length > 0) {
-            const composed = compose(allMiddleware);
-            finalHandler = async (ctx) => {
-              return composed(ctx, () => wrappedHandler(ctx));
-            };
-          }
-          finalHandler.originalHandler = originalHandler;
-          if (finalHandler !== wrappedHandler) {
-            wrappedHandler.originalHandler = originalHandler;
-          }
-          const tagName = instance.constructor.name;
-          const decoratedSpecs = instance[$routeSpec] || proto && proto[$routeSpec];
-          const userSpec = decoratedSpecs && decoratedSpecs.get(name);
-          const spec = { tags: [tagName], ...userSpec };
-          this.add({ method, path: normalizedPath, handler: finalHandler, spec, controller: instance });
-        }
-      }
-      if (routesAttached === 0) {
-        console.warn(`No routes attached to controller ${instance.constructor.name}`);
-      }
-      instance[$isMounted] = true;
+      this.scanControllerRoutes(prefix, controller);
     }
     return this;
   }
@@ -2045,8 +1854,6 @@ class ShokupanRouter {
    */
   async internalRequest(arg) {
     const options = typeof arg === "string" ? { path: arg } : arg;
-    const store = asyncContext.getStore();
-    store?.get("req");
     let url = options.path;
     if (!url.startsWith("http")) {
       const base = `http://${this.rootConfig?.hostname || "localhost"}:${this.rootConfig.port || 3e3}`;
@@ -2089,7 +1896,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) {
@@ -2098,12 +1905,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) {
@@ -2132,7 +1939,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) {
@@ -2158,6 +1965,254 @@ class ShokupanRouter {
     wrapped.originalHandler = originalHandler.originalHandler ?? originalHandler;
     return wrapped;
   }
+  mountRouter(prefix, router) {
+    if (router[$isMounted]) {
+      throw new Error("Router is already mounted");
+    }
+    router[$mountPath] = prefix;
+    if (!router.metadata) {
+      const info = getCallerInfo();
+      router.metadata = {
+        file: info.file,
+        line: info.line,
+        name: "MountedRouter"
+      };
+    }
+    this[$childRouters].push(router);
+    router[$parent] = this;
+    const setRouterContext = (router2) => {
+      router2[$appRoot] = this.root;
+      router2[$childRouters].forEach((child) => setRouterContext(child));
+    };
+    setRouterContext(router);
+    router[$appRoot] = this.root;
+    router[$isMounted] = true;
+  }
+  scanControllerRoutes(prefix, controller) {
+    let instance = controller;
+    if (typeof controller === "function") {
+      instance = Container.resolve(controller);
+      const controllerPath = controller[$controllerPath];
+      if (controllerPath) {
+        const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
+        prefix = p1 + p2;
+        if (!prefix) prefix = "/";
+      }
+    } else {
+      const ctor = instance.constructor;
+      const controllerPath = ctor[$controllerPath];
+      if (controllerPath) {
+        const p1 = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        const p2 = controllerPath.startsWith("/") ? controllerPath : "/" + controllerPath;
+        prefix = p1 + p2;
+        if (!prefix) prefix = "/";
+      }
+    }
+    instance[$mountPath] = prefix;
+    const info = getCallerInfo();
+    instance.metadata = {
+      file: info.file,
+      line: info.line,
+      name: instance.constructor.name
+    };
+    this[$childControllers].push(instance);
+    const controllerMiddleware = (typeof controller === "function" ? controller[$middleware] : instance[$middleware]) || [];
+    const proto = Object.getPrototypeOf(instance);
+    const methods = /* @__PURE__ */ new Set();
+    let current = proto;
+    while (current && current !== Object.prototype) {
+      Object.getOwnPropertyNames(current).forEach((name) => methods.add(name));
+      current = Object.getPrototypeOf(current);
+    }
+    Object.getOwnPropertyNames(instance).forEach((name) => methods.add(name));
+    const decoratedRoutes = instance[$routeMethods] || proto && proto[$routeMethods];
+    const decoratedArgs = instance[$routeArgs] || proto && proto[$routeArgs];
+    const methodMiddlewareMap = instance[$middleware] || proto && proto[$middleware];
+    const decoratedEvents = instance[$eventMethods] || proto && proto[$eventMethods];
+    let routesAttached = 0;
+    for (let i = 0; i < Array.from(methods).length; i++) {
+      const name = Array.from(methods)[i];
+      if (name === "constructor") continue;
+      if (["arguments", "caller", "callee"].includes(name)) continue;
+      const originalHandler = instance[name];
+      if (typeof originalHandler !== "function") continue;
+      let method;
+      let subPath = "";
+      if (decoratedRoutes && decoratedRoutes.has(name)) {
+        const config = decoratedRoutes.get(name);
+        method = config.method;
+        subPath = config.path;
+      } else {
+        for (let j = 0; j < HTTPMethods.length; j++) {
+          const m = HTTPMethods[j];
+          if (name.toUpperCase().startsWith(m)) {
+            method = m;
+            const rest = name.slice(m.length);
+            if (rest.length === 0) {
+              subPath = "/";
+            } else {
+              subPath = "";
+              let buffer = "";
+              const flush = () => {
+                if (buffer.length > 0) {
+                  subPath += "/" + buffer.toLowerCase();
+                  buffer = "";
+                }
+              };
+              for (let i2 = 0; i2 < rest.length; i2++) {
+                const char = rest[i2];
+                if (char === "$") {
+                  flush();
+                  subPath += "/:";
+                  continue;
+                }
+                buffer += char;
+              }
+              if (buffer.length > 0) flush();
+              subPath = rest.replace(/\$/g, "/:").replace(/([a-z0-9])([A-Z])/g, "$1/$2").toLowerCase();
+              if (!subPath.startsWith("/")) {
+                subPath = "/" + subPath;
+              }
+            }
+            break;
+          }
+        }
+      }
+      if (method) {
+        routesAttached++;
+        const cleanPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        const cleanSubPath = subPath === "/" ? "" : subPath;
+        let joined;
+        if (cleanSubPath.length === 0) {
+          joined = cleanPrefix;
+        } else if (cleanSubPath.startsWith("/")) {
+          joined = cleanPrefix + cleanSubPath;
+        } else {
+          joined = cleanPrefix + "/" + cleanSubPath;
+        }
+        const fullPath = joined || "/";
+        const normalizedPath = fullPath.replace(/\/+/g, "/");
+        const methodMw = methodMiddlewareMap instanceof Map ? methodMiddlewareMap.get(name) || [] : [];
+        const allMiddleware = [...controllerMiddleware, ...methodMw];
+        const routeArgs = decoratedArgs && decoratedArgs.get(name);
+        const wrappedHandler = async (ctx) => {
+          let args = [ctx];
+          if (routeArgs?.length > 0) {
+            args = [];
+            const sortedArgs = [...routeArgs].sort((a, b) => a.index - b.index);
+            for (let k = 0; k < sortedArgs.length; k++) {
+              const arg = sortedArgs[k];
+              switch (arg.type) {
+                case RouteParamType.BODY:
+                  try {
+                    if (ctx.req.headers.get("content-type")?.includes("application/json")) {
+                      args[arg.index] = await ctx.req.json();
+                    } else {
+                      const text = await ctx.req.text();
+                      if (!text) {
+                        args[arg.index] = {};
+                      } else {
+                        args[arg.index] = JSON.parse(text);
+                      }
+                    }
+                  } catch (e) {
+                    const err = new Error("Invalid JSON body");
+                    err.status = 400;
+                    throw err;
+                  }
+                  break;
+                case RouteParamType.PARAM:
+                  args[arg.index] = arg.name ? ctx.params[arg.name] : ctx.params;
+                  break;
+                case RouteParamType.QUERY: {
+                  const url = new URL(ctx.req.url);
+                  if (arg.name) {
+                    const vals = url.searchParams.getAll(arg.name);
+                    args[arg.index] = vals.length > 1 ? vals : vals[0];
+                  } else {
+                    const query = {};
+                    const keys = Object.keys(url.searchParams);
+                    for (let k2 = 0; k2 < keys.length; k2++) {
+                      const key = keys[k2];
+                      const vals = url.searchParams.getAll(key);
+                      query[key] = vals.length > 1 ? vals : vals[0];
+                    }
+                    args[arg.index] = query;
+                  }
+                  break;
+                }
+                case RouteParamType.HEADER:
+                  args[arg.index] = arg.name ? ctx.req.headers.get(arg.name) : ctx.req.headers;
+                  break;
+                case RouteParamType.REQUEST:
+                  args[arg.index] = ctx.req;
+                  break;
+                case RouteParamType.CONTEXT:
+                  args[arg.index] = ctx;
+                  break;
+              }
+            }
+          }
+          const tracedOriginalHandler = ctx.app?.applicationConfig.enableTracing ? traceHandler(originalHandler, normalizedPath) : originalHandler;
+          return tracedOriginalHandler.apply(instance, args);
+        };
+        let finalHandler = wrappedHandler;
+        if (allMiddleware.length > 0) {
+          const composed = compose(allMiddleware);
+          finalHandler = async (ctx) => {
+            return composed(ctx, () => wrappedHandler(ctx));
+          };
+        }
+        finalHandler.originalHandler = originalHandler;
+        if (finalHandler !== wrappedHandler) {
+          wrappedHandler.originalHandler = originalHandler;
+        }
+        const tagName = instance.constructor.name;
+        const decoratedSpecs = instance[$routeSpec] || proto && proto[$routeSpec];
+        const userSpec = decoratedSpecs && decoratedSpecs.get(name);
+        const spec = { tags: [tagName], ...userSpec };
+        this.add({ method, path: normalizedPath, handler: finalHandler, spec, controller: instance });
+      }
+      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);
+        };
+        this.event(config.eventName, wrappedHandler);
+      }
+    }
+    if (routesAttached === 0) {
+      console.warn(`No routes attached to controller ${instance.constructor.name}`);
+    }
+    instance[$isMounted] = true;
+  }
   /**
    * Find a route matching the given method and path.
    * @param method HTTP method
@@ -2284,7 +2339,7 @@ class ShokupanRouter {
     if (effectiveRenderer) {
       const innerHandler = wrappedHandler;
       wrappedHandler = async (ctx) => {
-        ctx.renderer = effectiveRenderer;
+        ctx.setRenderer(effectiveRenderer);
         return innerHandler(ctx);
       };
     }
@@ -2315,8 +2370,10 @@ class ShokupanRouter {
           Promise.resolve().then(async () => {
             try {
               const timestamp = Date.now();
-              const key = `${timestamp}-${handler.name || "anonymous"}-${Math.random().toString(36).substring(7)}`;
-              await datastore.set("middleware_tracking", key, {
+              await datastore.set(new RecordId("middleware_tracking", {
+                timestamp,
+                name: handler.name || "anonymous"
+              }), {
                 name: handler.name || "anonymous",
                 path: ctx.path,
                 timestamp,
@@ -2334,7 +2391,7 @@ class ShokupanRouter {
               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) {
+              if (results?.[0]?.count > maxCapacity) {
                 const toDelete = results[0].count - maxCapacity;
                 await datastore.query(`DELETE middleware_tracking ORDER BY timestamp ASC LIMIT ${toDelete}`);
               }
@@ -2411,7 +2468,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);
@@ -2429,7 +2486,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;
   }
@@ -2542,7 +2599,7 @@ class ShokupanRouter {
     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) => {
         const hookId = `hook_${name}_${fn.name || index}`;
@@ -2615,6 +2672,7 @@ const defaults = {
   hostname: "localhost",
   development: process.env.NODE_ENV !== "production",
   enableAsyncLocalStorage: false,
+  enableHttpBridge: false,
   reusePort: false
 };
 trace.getTracer("shokupan.application");
@@ -2623,6 +2681,7 @@ class Shokupan extends ShokupanRouter {
   openApiSpec;
   composedMiddleware;
   cpuMonitor;
+  server;
   get logger() {
     return this.applicationConfig.logger;
   }
@@ -2686,6 +2745,13 @@ class Shokupan extends ShokupanRouter {
     }
     return this;
   }
+  /**
+   * Registers a plugin.
+   */
+  register(plugin, options) {
+    plugin.onInit(this, options);
+    return this;
+  }
   startupHooks = [];
   /**
    * Registers a callback to be executed before the server starts listening.
@@ -2724,6 +2790,7 @@ class Shokupan extends ShokupanRouter {
       this.cpuMonitor = new SystemCpuMonitor();
       this.cpuMonitor.start();
     }
+    const self = this;
     const serveOptions = {
       port: finalPort,
       hostname: this.applicationConfig.hostname,
@@ -2735,8 +2802,61 @@ 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;
+                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);
@@ -2748,12 +2868,40 @@ class Shokupan extends ShokupanRouter {
     };
     let factory = this.applicationConfig.serverFactory;
     if (!factory && typeof Bun === "undefined") {
-      const { createHttpServer } = await import("./server-adapter-0xH174zz.js");
+      const { createHttpServer } = await import("./http-server-CCeagTyU.js");
       factory = createHttpServer();
     }
-    const server = factory ? await factory(serveOptions) : Bun.serve(serveOptions);
+    this.server = factory ? await factory(serveOptions) : Bun.serve(serveOptions);
     console.log(`Shokupan server listening on http://${serveOptions.hostname}:${serveOptions.port}`);
-    return server;
+    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);
@@ -2817,19 +2965,19 @@ class Shokupan extends ShokupanRouter {
           "http.method": req.method
         }
       };
-      const parent = store?.get("span");
+      const parent = store?.span;
       const ctx = parent ? trace.setSpan(context.active(), parent) : void 0;
       return tracer2.startActiveSpan(`${req.method} ${new URL(req.url).pathname}`, attrs, ctx, (span) => {
-        const ctxMap = /* @__PURE__ */ new Map();
-        ctxMap.set("span", span);
-        ctxMap.set("request", req);
-        return asyncContext.run(ctxMap, () => this.handleRequest(req, server).finally(() => span.end()));
+        const ctxStore = new RequestContextStore();
+        ctxStore.span = span;
+        ctxStore.request = req;
+        return asyncContext.run(ctxStore, () => this.handleRequest(req, server).finally(() => span.end()));
       });
     }
     if (this.applicationConfig.enableAsyncLocalStorage) {
-      const ctxMap = /* @__PURE__ */ new Map();
-      ctxMap.set("request", req);
-      return asyncContext.run(ctxMap, () => this.handleRequest(req, server));
+      const ctxStore = new RequestContextStore();
+      ctxStore.request = req;
+      return asyncContext.run(ctxStore, () => this.handleRequest(req, server));
     }
     return this.handleRequest(req, server);
   }
@@ -2851,24 +2999,34 @@ 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.params = match.params;
             await bodyParsing;
             return match.handler(ctx);
           }
+          if (ctx.upgrade()) {
+            return void 0;
+          }
           return null;
         });
         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.response.status !== 200 || ctx.response.hasPopulatedHeaders) {
+          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 {
-            response = ctx.text("Not Found", 404);
+            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", HTTP_STATUS.NOT_FOUND);
+            }
           }
         } else if (typeof result === "object") {
           response = ctx.json(result);
@@ -2879,10 +3037,9 @@ class Shokupan extends ShokupanRouter {
         await this.runHooks("onResponseStart", ctx, response);
         return response;
       } catch (err) {
-        console.error(err);
-        const span = asyncContext.getStore()?.get("span");
+        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);
@@ -2904,16 +3061,188 @@ 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;
     });
   }
 }
+function RateLimitMiddleware(options = {}) {
+  const windowMs = options.windowMs || 60 * 1e3;
+  const max = options.limit || options.max || 5;
+  const message = options.message || "Too many requests, please try again later.";
+  const statusCode = options.statusCode || 429;
+  const headers = options.headers !== false;
+  const mode = options.mode || "user";
+  const trustedProxies = options.trustedProxies || [];
+  const keyGenerator = options.keyGenerator || ((ctx) => {
+    if (mode === "absolute") {
+      return "global";
+    }
+    const xForwardedFor = ctx.headers.get("x-forwarded-for");
+    if (xForwardedFor && trustedProxies.length > 0) {
+      const ips = xForwardedFor.split(",").map((ip) => ip.trim());
+      for (let i = ips.length - 1; i >= 0; i--) {
+        const ip = ips[i];
+        if (!trustedProxies.includes(ip)) {
+          if (/^[\d.:a-fA-F]+$/.test(ip)) {
+            return ip;
+          }
+        }
+      }
+    }
+    return ctx.server?.requestIP?.(ctx.request)?.address || "unknown";
+  });
+  const skip = options.skip || (() => false);
+  const hits = /* @__PURE__ */ new Map();
+  const interval = setInterval(() => {
+    const now = Date.now();
+    const entries = Array.from(hits.entries());
+    for (let i = 0; i < entries.length; i++) {
+      const [key, record] = entries[i];
+      if (record.resetTime <= now) {
+        hits.delete(key);
+      }
+    }
+  }, windowMs);
+  if (interval.unref) interval.unref();
+  const rateLimitMiddleware = async function RateLimitMiddleware2(ctx, next) {
+    if (skip(ctx)) return next();
+    const key = keyGenerator(ctx);
+    const now = Date.now();
+    let record = hits.get(key);
+    if (!record || record.resetTime <= now) {
+      record = {
+        hits: 0,
+        resetTime: now + windowMs
+      };
+      hits.set(key, record);
+    }
+    record.hits++;
+    const remaining = Math.max(0, max - record.hits);
+    const resetTime = Math.ceil(record.resetTime / 1e3);
+    const retryAfter = Math.ceil((record.resetTime - now) / 1e3);
+    const setHeaders = (res) => {
+      if (!headers || !res || !res.headers) return;
+      try {
+        res.headers.set("X-RateLimit-Limit", String(max));
+        res.headers.set("X-RateLimit-Remaining", String(remaining));
+        res.headers.set("X-RateLimit-Reset", String(resetTime));
+      } catch (e) {
+      }
+    };
+    if (record.hits > max) {
+      if (options.onRateLimited) {
+        const result = await options.onRateLimited(ctx, key);
+        if (result instanceof Response) {
+          return result;
+        }
+      }
+      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);
+      if (headers) {
+        setHeaders(res);
+        res.headers.set("Retry-After", String(retryAfter));
+      }
+      return res;
+    }
+    const response = await next();
+    if (response instanceof Response && headers) {
+      setHeaders(response);
+    }
+    return response;
+  };
+  rateLimitMiddleware.isBuiltin = true;
+  rateLimitMiddleware.pluginName = "RateLimit";
+  return rateLimitMiddleware;
+}
+function Controller(path = "/") {
+  return (target) => {
+    target[$controllerPath] = path;
+  };
+}
+function Use(...middleware) {
+  return (target, propertyKey, descriptor) => {
+    if (!propertyKey) {
+      const existing = target[$middleware] || [];
+      target[$middleware] = [...existing, ...middleware];
+    } else {
+      if (!target[$middleware]) {
+        target[$middleware] = /* @__PURE__ */ new Map();
+      }
+      const existing = target[$middleware].get(propertyKey) || [];
+      target[$middleware].set(propertyKey, [...existing, ...middleware]);
+    }
+  };
+}
+function createParamDecorator(type) {
+  return (name) => {
+    return (target, propertyKey, parameterIndex) => {
+      if (!target[$routeArgs]) {
+        target[$routeArgs] = /* @__PURE__ */ new Map();
+      }
+      if (!target[$routeArgs].has(propertyKey)) {
+        target[$routeArgs].set(propertyKey, []);
+      }
+      target[$routeArgs].get(propertyKey).push({
+        index: parameterIndex,
+        type,
+        name
+      });
+    };
+  };
+}
+const Body = createParamDecorator(RouteParamType.BODY);
+const Param = createParamDecorator(RouteParamType.PARAM);
+const Query = createParamDecorator(RouteParamType.QUERY);
+const Headers$1 = createParamDecorator(RouteParamType.HEADER);
+const Req = createParamDecorator(RouteParamType.REQUEST);
+const Ctx = createParamDecorator(RouteParamType.CONTEXT);
+function Spec(spec) {
+  return (target, propertyKey, descriptor) => {
+    if (!target[$routeSpec]) {
+      target[$routeSpec] = /* @__PURE__ */ new Map();
+    }
+    target[$routeSpec].set(propertyKey, spec);
+  };
+}
+function createMethodDecorator(method) {
+  return (path = "/") => {
+    return (target, propertyKey, descriptor) => {
+      if (!target[$routeMethods]) {
+        target[$routeMethods] = /* @__PURE__ */ new Map();
+      }
+      target[$routeMethods].set(propertyKey, {
+        method,
+        path
+      });
+    };
+  };
+}
+const Get = createMethodDecorator("GET");
+const Post = createMethodDecorator("POST");
+const Put = createMethodDecorator("PUT");
+const Delete = createMethodDecorator("DELETE");
+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));
+}
 class AuthPlugin extends ShokupanRouter {
   constructor(authConfig) {
     super();
@@ -2922,6 +3251,13 @@ class AuthPlugin extends ShokupanRouter {
     this.init();
   }
   secret;
+  onInit(app, options) {
+    if (options?.path) {
+      app.mount(options.path, this);
+    } else {
+      app.mount(options.path ?? "/", this);
+    }
+  }
   getProviderInstance(name, p) {
     switch (name) {
       case "github":
@@ -3074,73 +3410,809 @@ class AuthPlugin extends ShokupanRouter {
         provider,
         raw: data
       };
-    } else if (provider === "auth0" || provider === "okta") {
-      const domain = config.domain.startsWith("http") ? config.domain : `https://${config.domain}`;
-      const endpoint = provider === "auth0" ? `${domain}/userinfo` : `${domain}/oauth2/v1/userinfo`;
-      const res = await fetch(endpoint, {
-        headers: { Authorization: `Bearer ${token}` }
+    } else if (provider === "auth0" || provider === "okta") {
+      const domain = config.domain.startsWith("http") ? config.domain : `https://${config.domain}`;
+      const endpoint = provider === "auth0" ? `${domain}/userinfo` : `${domain}/oauth2/v1/userinfo`;
+      const res = await fetch(endpoint, {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      const data = await res.json();
+      user = {
+        id: data.sub,
+        name: data.name,
+        email: data.email,
+        picture: data.picture,
+        provider,
+        raw: data
+      };
+    } else if (provider === "apple") {
+      if (idToken) {
+        const payload = jose.decodeJwt(idToken);
+        user = {
+          id: payload.sub,
+          email: payload["email"],
+          provider,
+          raw: payload
+        };
+      }
+    } else if (provider === "oauth2") {
+      if (config.userInfoUrl) {
+        const res = await fetch(config.userInfoUrl, {
+          headers: { Authorization: `Bearer ${token}` }
+        });
+        const data = await res.json();
+        user = {
+          id: data.id || data.sub || "unknown",
+          name: data.name,
+          email: data.email,
+          picture: data.picture,
+          provider,
+          raw: data
+        };
+      }
+    }
+    return user;
+  }
+  /**
+   * Middleware to verify JWT
+   */
+  getMiddleware() {
+    return async (ctx, next) => {
+      const authHeader = ctx.req.headers.get("Authorization");
+      let token = authHeader?.startsWith("Bearer ") ? authHeader.substring(7) : null;
+      if (!token) {
+        const cookieHeader = ctx.req.headers.get("Cookie");
+        token = cookieHeader?.match(/auth_token=([^;]+)/)?.[1] || null;
+      }
+      if (token) {
+        try {
+          const { payload } = await jose.jwtVerify(token, this.secret);
+          ctx.user = payload;
+        } catch {
+        }
+      }
+      return next();
+    };
+  }
+}
+class ClusterPlugin {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  onInit(app) {
+    const originalListen = app.listen.bind(app);
+    const { workers = "auto", silent = false, sticky = false } = this.options;
+    const isBun = typeof Bun !== "undefined";
+    const numCPUs = os__default.cpus().length;
+    const numWorkers = workers === "auto" || workers === -1 ? numCPUs : workers;
+    if (numWorkers <= 1) {
+      return;
+    }
+    app.listen = async (port) => {
+      const finalPort = port ?? app.applicationConfig.port ?? 3e3;
+      if (isBun) {
+        return this.handleBun(app, finalPort, numWorkers, originalListen);
+      } else {
+        return this.handleNode(app, finalPort, numWorkers, originalListen, silent, sticky);
+      }
+    };
+  }
+  async handleBun(app, port, workers, originalListen) {
+    const workerId = process.env["SHOKUPAN_WORKER_ID"];
+    if (workerId) {
+      app.applicationConfig.reusePort = true;
+      return originalListen(port);
+    }
+    console.log(`[Cluster] Starting ${workers} Bun workers on port ${port}...`);
+    const spawnWorker = (id) => {
+      Bun.spawn([process.argv0, ...process.argv.slice(1)], {
+        env: { ...process.env, SHOKUPAN_WORKER_ID: id },
+        stdio: ["inherit", "inherit", "inherit"],
+        onExit(proc, exitCode, signalCode, error) {
+          console.log(`[Cluster] Worker ${id} died (code: ${exitCode}). Restarting...`);
+          spawnWorker(id);
+        }
+      });
+    };
+    for (let i = 0; i < workers; i++) {
+      spawnWorker(process.pid + "_" + i + 1);
+    }
+    setInterval(() => {
+    }, 1e3 * 60 * 60);
+    return {
+      stop: () => {
+      },
+      port
+    };
+  }
+  async handleNode(app, port, workers, originalListen, silent, sticky) {
+    if (cluster.isPrimary) {
+      console.log(`[Cluster] Master ${process.pid} is running`);
+      const fork = () => cluster.fork(process.env);
+      for (let i = 0; i < workers; i++) {
+        fork();
+      }
+      cluster.on("exit", (worker, code, signal) => {
+        console.log(`[Cluster] Worker ${worker.process.pid} died. Restarting...`);
+        fork();
+      });
+      if (sticky) {
+        const server = net.createServer({ pauseOnConnect: true }, (connection) => {
+          const remote = connection.remoteAddress || "";
+          let hash = 0;
+          for (let i = 0; i < remote.length; i++) {
+            hash = (hash << 5) - hash + remote.charCodeAt(i);
+            hash |= 0;
+          }
+          const index = Math.abs(hash) % workers;
+          const worker = Object.values(cluster.workers)[index];
+          if (worker) {
+            worker.send("sticky-session:connection", connection);
+          } else {
+            connection.end();
+          }
+        });
+        server.listen(port, () => {
+          console.log(`[Cluster] Sticky Load Balancer listening on port ${port}`);
+        });
+        return {
+          close: () => server.close(),
+          port
+        };
+      } else {
+        return {
+          close: () => {
+          },
+          // Master controls
+          port
+        };
+      }
+    } else {
+      if (sticky) {
+        const server = await originalListen(0);
+        process.on("message", (message, handle) => {
+          if (message !== "sticky-session:connection") return;
+          if (!handle) return;
+          server.emit("connection", handle);
+          handle.resume();
+        });
+        return server;
+      } else {
+        return originalListen(port);
+      }
+    }
+  }
+}
+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 {
+  currentIntervalStart = {};
+  pendingDetails = {};
+  eventLoopHistogram = monitorEventLoopDelay({ resolution: 10 });
+  timer = null;
+  constructor() {
+    this.eventLoopHistogram.enable();
+    const now = Date.now();
+    INTERVALS.forEach((int) => {
+      this.currentIntervalStart[int.label] = this.alignTimestamp(now, int.ms);
+      this.pendingDetails[int.label] = [];
+    });
+    this.timer = setInterval(() => this.collect(), 1e4);
+  }
+  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();
+      console.log("[MetricsCollector] collect() called at", new Date(now).toISOString());
+      for (const int of INTERVALS) {
+        const start = this.currentIntervalStart[int.label];
+        if (now >= start + int.ms) {
+          console.log(`[MetricsCollector] Flushing ${int.label} interval (boundary crossed)`);
+          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];
+    console.log(`[MetricsCollector] flushInterval(${label}) - ${reqs.length} requests pending`);
+    this.pendingDetails[label] = [];
+    if (reqs.length === 0) {
+      console.log(`[MetricsCollector] No requests for ${label}, skipping persist`);
+      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)
+      }
+    };
+    console.log(`[MetricsCollector] Persisting ${label} metric at timestamp ${timestamp}`);
+    try {
+      const recordId = new RecordId("metrics", timestamp);
+      await datastore.set(recordId, metric);
+      console.log(`[MetricsCollector] ✓ Successfully saved ${label} metric to datastore`);
+      const test = await datastore.get(recordId);
+      console.log(`[MetricsCollector] DEBUG: Immediate .get() returned:`, test ? "DATA" : "NULL");
+      const queryTest = await datastore.query("SELECT * FROM metrics WHERE id = $id", { id: recordId });
+      console.log(`[MetricsCollector] DEBUG: Query by id returned ${queryTest[0]?.length || 0} records`);
+    } 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;
+  }
+  static __dirname = dirname(fileURLToPath(import.meta.url));
+  // 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;
+  }
+  router = new ShokupanRouter();
+  metrics = {
+    totalRequests: 0,
+    successfulRequests: 0,
+    failedRequests: 0,
+    activeRequests: 0,
+    averageTotalTime_ms: 0,
+    recentTimings: [],
+    logs: [],
+    rateLimitedCounts: {},
+    nodeMetrics: {},
+    edgeMetrics: {}
+  };
+  eta = new Eta({
+    views: Dashboard.getBasePath() + "/static",
+    cache: false
+  });
+  startTime = Date.now();
+  instrumented = false;
+  metricsCollector = new MetricsCollector();
+  // ShokupanPlugin interface implementation
+  onInit(app, options) {
+    this[$appRoot] = app;
+    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();
+  }
+  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 datastore.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 datastore.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 data = await res.json();
-      user = {
-        id: data.sub,
-        name: data.name,
-        email: data.email,
-        picture: data.picture,
-        provider,
-        raw: data
+    });
+    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
       };
-    } else if (provider === "apple") {
-      if (idToken) {
-        const payload = jose.decodeJwt(idToken);
-        user = {
-          id: payload.sub,
-          email: payload["email"],
-          provider,
-          raw: payload
-        };
+      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 datastore.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 datastore.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 datastore.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 datastore.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);
       }
-    } else if (provider === "oauth2") {
-      if (config.userInfoUrl) {
-        const res = await fetch(config.userInfoUrl, {
-          headers: { Authorization: `Bearer ${token}` }
+      const registry = app?.getComponentRegistry?.();
+      if (registry) {
+        this.assignIdsToRegistry(registry, "root");
+      }
+      return ctx.json({ registry: registry || {} });
+    });
+    this.router.get("/requests", async (ctx) => {
+      const result = await datastore.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 datastore.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 datastore.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
         });
-        const data = await res.json();
-        user = {
-          id: data.id || data.sub || "unknown",
-          name: data.name,
-          email: data.email,
-          picture: data.picture,
-          provider,
-          raw: data
-        };
+        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 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 linkPattern = this.getLinkPattern();
+      const template = await readFile(Dashboard.getBasePath() + "/template.eta", "utf8");
+      return ctx.html(this.eta.renderString(template, {
+        metrics: this.metrics,
+        uptime,
+        rootPath: process.cwd(),
+        linkPattern,
+        headers: this.dashboardConfig.getRequestHeaders?.()
+      }));
+    });
+  }
+  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
+      };
     }
-    return user;
+    const m = this.metrics.nodeMetrics[id];
+    m.requests++;
+    m.totalTime += duration;
+    if (isError) m.failures++;
   }
-  /**
-   * Middleware to verify JWT
-   */
-  getMiddleware() {
-    return async (ctx, next) => {
-      const authHeader = ctx.req.headers.get("Authorization");
-      let token = authHeader?.startsWith("Bearer ") ? authHeader.substring(7) : null;
-      if (!token) {
-        const cookieHeader = ctx.req.headers.get("Cookie");
-        token = cookieHeader?.match(/auth_token=([^;]+)/)?.[1] || null;
-      }
-      if (token) {
+  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 datastore.set(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 {
-          const { payload } = await jose.jwtVerify(token, this.secret);
-          ctx.user = payload;
-        } catch {
+          await datastore.set(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);
         }
       }
-      return next();
     };
   }
+  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);
+}
+const eta = new Eta();
+class ScalarPlugin extends ShokupanRouter {
+  constructor(pluginOptions = {}) {
+    pluginOptions.config ??= {};
+    super();
+    this.pluginOptions = pluginOptions;
+    this.init();
+  }
+  onInit(app, options) {
+    if (options?.path) {
+      app.mount(options.path, this);
+    } else {
+      app.mount(options.path ?? "/", this);
+    }
+    this.onMount(app);
+  }
+  init() {
+    this.get("/", (ctx) => {
+      let path = ctx.url.toString();
+      if (!path.endsWith("/")) path += "/";
+      return ctx.html(eta.renderString(`<!doctype html>
+                <html>
+                <head>
+                    <title>API Reference</title>
+                    <meta charset = "utf-8" />
+                    <meta name="viewport" content = "width=device-width, initial-scale=1" />
+                </head>
+
+                <body>
+                    <div id="app"></div>
+                    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
+                    <script>
+                        Scalar.createApiReference('#app', [{ ...<%~ JSON.stringify(it.config.baseDocument) %>,
+                            url: "<%= it.path %>openapi.json",
+                        }
+                    ])
+                    <\/script>
+                </body>
+
+                </html>`, { path, config: this.pluginOptions }));
+    });
+    this.get("/openapi.json", async (ctx) => {
+      let spec;
+      if (this.root.openApiSpec) {
+        try {
+          spec = structuredClone(this.root.openApiSpec);
+        } catch (e) {
+          spec = Object.assign({}, this.root.openApiSpec);
+        }
+      } else {
+        spec = await (this.root || this).generateApiSpec();
+      }
+      if (this.pluginOptions.baseDocument) {
+        deepMerge(spec, this.pluginOptions.baseDocument);
+      }
+      return ctx.json(spec);
+    });
+  }
+  // New lifecycle method to be called by router.mount
+  onMount(parent) {
+    if (parent.onStart) {
+      parent.onStart(async () => {
+        if (this.pluginOptions.enableStaticAnalysis) {
+          try {
+            const entrypoint = process.argv[1];
+            console.log(`[ScalarPlugin] Running eager static analysis on entrypoint: ${entrypoint}`);
+            const analyzer = new OpenAPIAnalyzer(process.cwd(), entrypoint);
+            let staticSpec = await analyzer.analyze();
+            if (!this.pluginOptions.baseDocument) this.pluginOptions.baseDocument = {};
+            deepMerge(this.pluginOptions.baseDocument, staticSpec);
+            console.log("[ScalarPlugin] Static analysis completed successfully.");
+          } catch (err) {
+            console.error("[ScalarPlugin] Failed to run static analysis:", err);
+          }
+        }
+      });
+    }
+  }
 }
 function Compression(options = {}) {
   const threshold = options.threshold ?? 512;
+  const allowedAlgorithms = new Set(options.allowedAlgorithms ?? ["br", "gzip", "zstd", "deflate"]);
   const compressionMiddleware = async function CompressionMiddleware(ctx, next) {
     const acceptEncoding = ctx.headers.get("accept-encoding") || "";
     let method = null;
@@ -3153,24 +4225,27 @@ function Compression(options = {}) {
     } else if (acceptEncoding.includes("gzip")) method = "gzip";
     else if (acceptEncoding.includes("deflate")) method = "deflate";
     if (!method) return next();
+    if (!allowedAlgorithms.has(method)) {
+      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 {
@@ -3707,77 +4782,6 @@ function enableOpenApiValidation(app) {
     precompileValidators(app, spec);
   });
 }
-const eta = new Eta();
-class ScalarPlugin extends ShokupanRouter {
-  constructor(pluginOptions = {}) {
-    pluginOptions.config ??= {};
-    super();
-    this.pluginOptions = pluginOptions;
-    this.init();
-  }
-  init() {
-    this.get("/", (ctx) => {
-      let path = ctx.url.toString();
-      if (!path.endsWith("/")) path += "/";
-      return ctx.html(eta.renderString(`<!doctype html>
-                <html>
-                <head>
-                    <title>API Reference</title>
-                    <meta charset = "utf-8" />
-                    <meta name="viewport" content = "width=device-width, initial-scale=1" />
-                </head>
-
-                <body>
-                    <div id="app"></div>
-                    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
-                    <script>
-                        Scalar.createApiReference('#app', [{ ...<%~ JSON.stringify(it.config.baseDocument) %>,
-                            url: "<%= it.path %>openapi.json",
-                        }
-                    ])
-                    <\/script>
-                </body>
-
-                </html>`, { path, config: this.pluginOptions }));
-    });
-    this.get("/openapi.json", async (ctx) => {
-      let spec;
-      if (this.root.openApiSpec) {
-        try {
-          spec = structuredClone(this.root.openApiSpec);
-        } catch (e) {
-          spec = Object.assign({}, this.root.openApiSpec);
-        }
-      } else {
-        spec = await (this.root || this).generateApiSpec();
-      }
-      if (this.pluginOptions.baseDocument) {
-        deepMerge(spec, this.pluginOptions.baseDocument);
-      }
-      return ctx.json(spec);
-    });
-  }
-  // New lifecycle method to be called by router.mount
-  onMount(parent) {
-    if (parent.onStart) {
-      parent.onStart(async () => {
-        if (this.pluginOptions.enableStaticAnalysis) {
-          try {
-            const entrypoint = process.argv[1];
-            console.log(`[ScalarPlugin] Running eager static analysis on entrypoint: ${entrypoint}`);
-            const analyzer = new OpenAPIAnalyzer(process.cwd(), entrypoint);
-            let staticSpec = await analyzer.analyze();
-            if (!this.pluginOptions.baseDocument) this.pluginOptions.baseDocument = {};
-            deepMerge(this.pluginOptions.baseDocument, staticSpec);
-            console.log("[ScalarPlugin] Static analysis completed successfully.");
-          } catch (err) {
-            console.error("[ScalarPlugin] Failed to run static analysis:", err);
-          }
-        }
-      });
-    }
-  }
-}
 function SecurityHeaders(options = {}) {
   const securityHeadersMiddleware = async function SecurityHeadersMiddleware(ctx, next) {
     const headers = {};
@@ -3901,18 +4905,18 @@ class MemoryStore extends EventEmitter {
   }
   set(sid, sess, cb) {
     this.sessions[sid] = JSON.stringify(sess);
-    cb && cb();
+    cb?.();
   }
   destroy(sid, cb) {
     delete this.sessions[sid];
-    cb && cb();
+    cb?.();
   }
   touch(sid, sess, cb) {
     const current = this.sessions[sid];
     if (current) {
       this.sessions[sid] = JSON.stringify(sess);
     }
-    cb && cb();
+    cb?.();
   }
   all(cb) {
     const result = {};
@@ -3928,7 +4932,7 @@ class MemoryStore extends EventEmitter {
   }
   clear(cb) {
     this.sessions = {};
-    cb && cb();
+    cb?.();
   }
 }
 function sign(val, secret) {
@@ -4107,29 +5111,51 @@ 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,
   AuthPlugin,
   Body,
+  ClusterPlugin,
   Compression,
   Container,
   Controller,
   Cors,
   Ctx,
+  Dashboard,
   Delete,
+  Event,
   Get,
   HTTPMethods,
   Head,
@@ -4147,16 +5173,13 @@ export {
   RateLimitMiddleware,
   Req,
   RouteParamType,
-  RouterRegistry,
   ScalarPlugin,
   SecurityHeaders,
   Session,
   Shokupan,
-  ShokupanApplicationTree,
   ShokupanContext,
   ShokupanRequest,
   ShokupanResponse,
-  ShokupanRouter,
   Spec,
   Use,
   ValidationError,