shokupan 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,6 +1,8 @@
+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";
@@ -10,12 +12,45 @@ import { OAuth2Client, Okta, Auth0, Apple, MicrosoftEntraId, Google, GitHub, gen
 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 { randomUUID, createHmac } from "crypto";
 import { EventEmitter } from "events";
+const HTTP_STATUS = {
+  // 2xx Success
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  // 3xx Redirection
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  PERMANENT_REDIRECT: 308,
+  // 4xx Client Errors
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  // 5xx Server Errors
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504
+};
 const VALID_HTTP_STATUSES = /* @__PURE__ */ new Set([
   100,
   101,
@@ -145,6 +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;
@@ -182,23 +251,26 @@ class ShokupanContext {
   state;
   handlerStack = [];
   response;
-  _debug;
-  _finalResponse;
-  _rawBody;
+  [$debug];
+  [$finalResponse];
+  [$rawBody];
   // Raw body for compression optimization
   // Body caching to avoid double parsing
-  _url;
-  _cachedBody;
-  _bodyType;
-  _bodyParsed = false;
-  _bodyParseError;
-  _routeMatched = false;
+  [$url];
+  [$cachedBody];
+  [$bodyType];
+  [$bodyParsed] = false;
+  [$bodyParseError];
+  [$routeMatched] = false;
   // Cached URL properties to avoid repeated parsing
-  _cachedHostname;
-  _cachedProtocol;
-  _cachedHost;
-  _cachedOrigin;
-  _cachedQuery;
+  [$cachedHostname];
+  [$cachedProtocol];
+  [$cachedHost];
+  [$cachedOrigin];
+  [$cachedQuery];
+  [$ws];
+  [$socket];
+  [$io];
   /**
    * JSX Rendering Function
    */
@@ -206,12 +278,16 @@ class ShokupanContext {
   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
@@ -229,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;
@@ -254,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);
@@ -271,7 +347,7 @@ class ShokupanContext {
         q[key] = value;
       }
     }
-    this._cachedQuery = q;
+    this[$cachedQuery] = q;
     return q;
   }
   /**
@@ -284,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)
@@ -308,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
@@ -329,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
@@ -338,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
@@ -415,18 +523,18 @@ class ShokupanContext {
    * The body is only parsed once and cached for subsequent reads.
    */
   async body() {
-    if (this._bodyParseError) {
-      throw this._bodyParseError;
+    if (this[$bodyParseError]) {
+      throw this[$bodyParseError];
     }
-    if (this._bodyParsed) {
-      return this._cachedBody;
+    if (this[$bodyParsed]) {
+      return this[$cachedBody];
     }
     const contentType = this.request.headers.get("content-type") || "";
     if (contentType.includes("application/json") || contentType.includes("+json")) {
       const parserType = this.app?.applicationConfig?.jsonParser || "native";
       if (parserType === "native") {
         try {
-          this._cachedBody = await this.request.json();
+          this[$cachedBody] = await this.request.json();
         } catch (e) {
           throw e;
         }
@@ -434,18 +542,18 @@ class ShokupanContext {
         const rawText = await this.request.text();
         const { getJSONParser } = await import("./json-parser-B3dnQmCC.js");
         const parser = getJSONParser(parserType);
-        this._cachedBody = parser(rawText);
+        this[$cachedBody] = parser(rawText);
       }
-      this._bodyType = "json";
+      this[$bodyType] = "json";
     } else if (contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded")) {
-      this._cachedBody = await this.request.formData();
-      this._bodyType = "formData";
+      this[$cachedBody] = await this.request.formData();
+      this[$bodyType] = "formData";
     } else {
-      this._cachedBody = await this.request.text();
-      this._bodyType = "text";
+      this[$cachedBody] = await this.request.text();
+      this[$bodyType] = "text";
     }
-    this._bodyParsed = true;
-    return this._cachedBody;
+    this[$bodyParsed] = true;
+    return this[$cachedBody];
   }
   /**
    * Pre-parse the request body before handler execution.
@@ -453,7 +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") {
@@ -462,7 +570,7 @@ class ShokupanContext {
     try {
       await this.body();
     } catch (error) {
-      this._bodyParseError = error;
+      this[$bodyParseError] = error;
     }
   }
   /**
@@ -512,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
@@ -526,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
@@ -547,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
@@ -570,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
@@ -583,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
@@ -595,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
@@ -608,15 +727,15 @@ 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];
     }
   }
   /**
@@ -652,10 +771,10 @@ const compose = (middleware) => {
         return next ? next() : Promise.resolve();
       }
       const fn = middleware[i];
-      if (!context2._debug) {
+      if (!context2[$debug]) {
         return fn(context2, () => runner(i + 1));
       }
-      const debug = context2._debug;
+      const debug = context2[$debug];
       const debugId = fn._debugId || fn.name || "anonymous";
       const previousNode = debug.getCurrentNode();
       debug.trackEdge(previousNode, debugId);
@@ -731,21 +850,6 @@ function deepMerge(target, ...sources) {
   }
   return deepMerge(target, ...sources);
 }
-const $isApplication = /* @__PURE__ */ Symbol.for("Shokupan.app");
-const $appRoot = /* @__PURE__ */ Symbol.for("Shokupan.app-root");
-const $isMounted = /* @__PURE__ */ Symbol("Shokupan.isMounted");
-const $routeMethods = /* @__PURE__ */ Symbol("Shokupan.routeMethods");
-const $routeArgs = /* @__PURE__ */ Symbol("Shokupan.routeArgs");
-const $controllerPath = /* @__PURE__ */ Symbol("Shokupan.controllerPath");
-const $middleware = /* @__PURE__ */ Symbol("Shokupan.middleware");
-const $isRouter = /* @__PURE__ */ Symbol.for("Shokupan.router");
-const $parent = /* @__PURE__ */ Symbol.for("Shokupan.parent");
-const $childRouters = /* @__PURE__ */ Symbol.for("Shokupan.child-routers");
-const $childControllers = /* @__PURE__ */ Symbol.for("Shokupan.child-controllers");
-const $mountPath = /* @__PURE__ */ Symbol.for("Shokupan.mount-path");
-const $dispatch = /* @__PURE__ */ Symbol.for("Shokupan.dispatch");
-const $routes = /* @__PURE__ */ Symbol.for("Shokupan.routes");
-const $routeSpec = /* @__PURE__ */ Symbol.for("Shokupan.routeSpec");
 const REGEX_PATTERNS = {
   QUERY_INT: /parseInt\(ctx\.query\.(\w+)\)/g,
   QUERY_FLOAT: /parseFloat\(ctx\.query\.(\w+)\)/g,
@@ -1132,6 +1236,35 @@ class RequestContextStore {
   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 || ".");
@@ -1284,18 +1417,16 @@ function serveStatic(config, prefix) {
   serveStaticMiddleware.pluginName = "ServeStatic";
   return serveStaticMiddleware;
 }
-let db;
-let dbPromise = null;
-let RecordId;
+const G = globalThis;
+G.__shokupan_db = G.__shokupan_db || null;
+G.__shokupan_db_promise = G.__shokupan_db_promise || null;
 async function ensureDb() {
-  if (db) return db;
-  if (dbPromise) return dbPromise;
-  dbPromise = (async () => {
+  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 Surreal = surreal.Surreal;
-      RecordId = surreal.RecordId;
       const engine = process.env["SHOKUPAN_DB_ENGINE"] === "memory" ? "mem://" : "rocksdb://database";
       const _db = new Surreal({
         engines: createNodeEngines()
@@ -1308,33 +1439,33 @@ async function ensureDb() {
             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";
         `);
-      db = _db;
-      return db;
+      G.__shokupan_db = _db;
+      return _db;
     } catch (e) {
-      dbPromise = null;
+      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 dbPromise;
+  return G.__shokupan_db_promise;
 }
 const datastore = {
-  async get(store, key) {
+  async get(recordId) {
     await ensureDb();
-    return db.select(new RecordId(store, key));
+    return G.__shokupan_db.select(recordId);
   },
-  async set(store, key, value) {
+  async set(recordId, value) {
     await ensureDb();
-    return db.create(new RecordId(store, key)).content(value);
+    return G.__shokupan_db.upsert(recordId).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;
+      return G.__shokupan_db.query(query, vars).collect();
     } catch (e) {
       console.error("DS ERROR:", e);
       throw e;
@@ -1345,7 +1476,7 @@ const datastore = {
   }
 };
 process.on("exit", async () => {
-  if (db) await db.close();
+  if (G.__shokupan_db) await G.__shokupan_db.close();
 });
 class Container {
   static services = /* @__PURE__ */ new Map();
@@ -1576,6 +1707,7 @@ class ShokupanRouter {
   metadata;
   // Metadata for the router itself
   currentGuards = [];
+  eventHandlers = /* @__PURE__ */ new Map();
   // Registry Accessor
   getComponentRegistry() {
     const controllerRoutesMap = /* @__PURE__ */ new Map();
@@ -1636,6 +1768,34 @@ class ShokupanRouter {
   isRouterInstance(target) {
     return typeof target === "object" && target !== null && $isRouter in target;
   }
+  /**
+   * Registers an event handler for WebSocket.
+   */
+  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.
    * 
@@ -1736,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) {
@@ -1745,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) {
@@ -1779,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) {
@@ -1869,6 +2029,7 @@ class ShokupanRouter {
     const decoratedRoutes = instance[$routeMethods] || proto && proto[$routeMethods];
     const decoratedArgs = instance[$routeArgs] || proto && proto[$routeArgs];
     const methodMiddlewareMap = instance[$middleware] || proto && proto[$middleware];
+    const decoratedEvents = instance[$eventMethods] || proto && proto[$eventMethods];
     let routesAttached = 0;
     for (let i = 0; i < Array.from(methods).length; i++) {
       const name = Array.from(methods)[i];
@@ -2013,6 +2174,39 @@ class ShokupanRouter {
         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}`);
@@ -2176,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,
@@ -2195,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}`);
               }
@@ -2272,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);
@@ -2290,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;
   }
@@ -2403,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}`;
@@ -2476,6 +2672,7 @@ const defaults = {
   hostname: "localhost",
   development: process.env.NODE_ENV !== "production",
   enableAsyncLocalStorage: false,
+  enableHttpBridge: false,
   reusePort: false
 };
 trace.getTracer("shokupan.application");
@@ -2484,6 +2681,7 @@ class Shokupan extends ShokupanRouter {
   openApiSpec;
   composedMiddleware;
   cpuMonitor;
+  server;
   get logger() {
     return this.applicationConfig.logger;
   }
@@ -2592,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,
@@ -2603,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);
@@ -2616,12 +2868,40 @@ class Shokupan extends ShokupanRouter {
     };
     let factory = this.applicationConfig.serverFactory;
     if (!factory && typeof Bun === "undefined") {
-      const { createHttpServer } = await import("./http-server-0xH174zz.js");
+      const { createHttpServer } = await import("./http-server-CCeagTyU.js");
       factory = createHttpServer();
     }
-    const server = factory ? await factory(serveOptions) : Bun.serve(serveOptions);
+    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);
@@ -2719,28 +2999,33 @@ class Shokupan extends ShokupanRouter {
           const bodyParsing = ["POST", "PUT", "PATCH", "DELETE"].includes(req.method) ? ctx.parseBody() : Promise.resolve();
           const match = this.find(req.method, ctx.path);
           if (match) {
-            ctx._routeMatched = true;
+            ctx[$routeMatched] = true;
             ctx.params = match.params;
             await bodyParsing;
             return match.handler(ctx);
           }
+          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._routeMatched) {
+          if (ctx[$finalResponse] instanceof Response) {
+            response = ctx[$finalResponse];
+          } else if (ctx.isUpgraded) {
+            return void 0;
+          } else if (ctx[$routeMatched]) {
             response = ctx.send(null, { status: ctx.response.status, headers: ctx.response.headers });
           } else {
-            if (ctx.response.status !== 200) {
+            if (ctx.response.status !== HTTP_STATUS.OK) {
               response = ctx.send(null, { status: ctx.response.status, headers: ctx.response.headers });
             } else {
-              response = ctx.text("Not Found", 404);
+              response = ctx.text("Not Found", HTTP_STATUS.NOT_FOUND);
             }
           }
         } else if (typeof result === "object") {
@@ -2752,10 +3037,9 @@ class Shokupan extends ShokupanRouter {
         await this.runHooks("onResponseStart", ctx, response);
         return response;
       } catch (err) {
-        console.error(err);
         const span = asyncContext.getStore()?.span;
         if (span) span.setStatus({ code: 2 });
-        const status = err.status || err.statusCode || 500;
+        const status = getErrorStatus(err);
         const body = { error: err.message || "Internal Server Error" };
         if (err.errors) body.errors = err.errors;
         await this.runHooks("onError", ctx, err);
@@ -2777,10 +3061,10 @@ class Shokupan extends ShokupanRouter {
     }
     return executionPromise.catch((err) => {
       if (err.message === "Request Timeout") {
-        return ctx.text("Request Timeout", 408);
+        return ctx.text("Request Timeout", HTTP_STATUS.REQUEST_TIMEOUT);
       }
       console.error("Unexpected error in request execution:", err);
-      return ctx.text("Internal Server Error", 500);
+      return ctx.text("Internal Server Error", HTTP_STATUS.INTERNAL_SERVER_ERROR);
     }).then(async (res) => {
       await this.runHooks("onResponseEnd", ctx, res);
       return res;
@@ -2948,6 +3232,14 @@ 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));
 }
@@ -3291,6 +3583,554 @@ class ClusterPlugin {
     }
   }
 }
+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 getIntervalStartTime = (interval) => {
+      if (!interval) return 0;
+      const intervalMap = {
+        "10s": 10 * 1e3,
+        "1m": 60 * 1e3,
+        "5m": 5 * 60 * 1e3,
+        "30m": 30 * 60 * 1e3,
+        "1h": 60 * 60 * 1e3,
+        "2h": 2 * 60 * 60 * 1e3,
+        "6h": 6 * 60 * 60 * 1e3,
+        "12h": 12 * 60 * 60 * 1e3,
+        "1d": 24 * 60 * 60 * 1e3,
+        "3d": 3 * 24 * 60 * 60 * 1e3,
+        "7d": 7 * 24 * 60 * 60 * 1e3,
+        "30d": 30 * 24 * 60 * 60 * 1e3
+      };
+      const ms = intervalMap[interval] || 0;
+      return ms ? Date.now() - ms : 0;
+    };
+    this.router.get("/requests/top", async (ctx) => {
+      const startTime = getIntervalStartTime(ctx.query["interval"]);
+      const result = await 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);
+      }
+      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
+        });
+        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
+      };
+    }
+    const m = this.metrics.nodeMetrics[id];
+    m.requests++;
+    m.totalTime += duration;
+    if (isError) m.failures++;
+  }
+  recordEdgeMetric(from, to) {
+    const key = `${from}|${to}`;
+    this.metrics.edgeMetrics[key] = (this.metrics.edgeMetrics[key] || 0) + 1;
+  }
+  getLinkPattern() {
+    const term = process.env["TERM_PROGRAM"] || "";
+    if (["vscode", "cursor", "antigravity"].some((t) => term.includes(t))) {
+      return "vscode://file/{{absolute}}:{{line}}";
+    }
+    return "file:///{{absolute}}:{{line}}";
+  }
+  getHooks() {
+    return {
+      onRequestStart: (ctx) => {
+        const app = this[$appRoot];
+        if (!this.instrumented && app) {
+          this.instrumentApp(app);
+        }
+        this.metrics.totalRequests++;
+        this.metrics.activeRequests++;
+        ctx._debugStartTime = performance.now();
+        ctx[$debug] = new Collector(this);
+      },
+      onResponseEnd: async (ctx, response) => {
+        this.metrics.activeRequests = Math.max(0, this.metrics.activeRequests - 1);
+        const start = ctx._debugStartTime;
+        let duration = 0;
+        if (start) {
+          duration = performance.now() - start;
+          this.updateTiming(duration);
+        }
+        const isError = response.status >= 400;
+        this.metricsCollector.recordRequest(duration, isError);
+        if (response.status >= 400) {
+          this.metrics.failedRequests++;
+          if (response.status === 429) {
+            const path = ctx.path;
+            this.metrics.rateLimitedCounts[path] = (this.metrics.rateLimitedCounts[path] || 0) + 1;
+          }
+          try {
+            const headers = {};
+            if (ctx.request.headers && typeof ctx.request.headers.forEach === "function") {
+              ctx.request.headers.forEach((v, k) => {
+                headers[k] = v;
+              });
+            }
+            await 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 {
+          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);
+        }
+      }
+    };
+  }
+  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 = {}) {
@@ -3389,23 +4229,23 @@ function Compression(options = {}) {
       return next();
     }
     let response = await next();
-    if (!(response instanceof Response) && ctx._finalResponse instanceof Response) {
-      response = ctx._finalResponse;
+    if (!(response instanceof Response) && ctx[$finalResponse] instanceof Response) {
+      response = ctx[$finalResponse];
     }
     if (response instanceof Response) {
       if (response.headers.has("Content-Encoding")) return response;
       let body;
       let bodySize;
-      if (ctx._rawBody !== void 0) {
-        if (typeof ctx._rawBody === "string") {
-          const encoded = new TextEncoder().encode(ctx._rawBody);
+      if (ctx[$rawBody] !== void 0) {
+        if (typeof ctx[$rawBody] === "string") {
+          const encoded = new TextEncoder().encode(ctx[$rawBody]);
           body = encoded;
           bodySize = encoded.byteLength;
-        } else if (ctx._rawBody instanceof Uint8Array) {
-          body = ctx._rawBody;
-          bodySize = ctx._rawBody.byteLength;
+        } else if (ctx[$rawBody] instanceof Uint8Array) {
+          body = ctx[$rawBody];
+          bodySize = ctx[$rawBody].byteLength;
         } else {
-          body = ctx._rawBody;
+          body = ctx[$rawBody];
           bodySize = body.byteLength;
         }
       } else {
@@ -4271,20 +5111,39 @@ 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,
@@ -4294,7 +5153,9 @@ export {
   Controller,
   Cors,
   Ctx,
+  Dashboard,
   Delete,
+  Event,
   Get,
   HTTPMethods,
   Head,